38369 lines
1.2 MiB
38369 lines
1.2 MiB
/**
|
|
* @license
|
|
* Video.js 5.10.2 <http://videojs.com/>
|
|
* Copyright Brightcove, Inc. <https://www.brightcove.com/>
|
|
* Available under Apache License Version 2.0
|
|
* <https://github.com/videojs/video.js/blob/master/LICENSE>
|
|
*
|
|
* Includes vtt.js <https://github.com/mozilla/vtt.js>
|
|
* Available under Apache License Version 2.0
|
|
* <https://github.com/mozilla/vtt.js/blob/master/LICENSE>
|
|
*/
|
|
/**
|
|
* and, appended:
|
|
* videojs-contrib-hls
|
|
* @version 3.0.2
|
|
* @copyright 2016 Brightcove, Inc
|
|
* @license Apache-2.0
|
|
*/
|
|
|
|
(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.videojs = 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(_dereq_,module,exports){
|
|
(function (global){
|
|
var topLevel = typeof global !== 'undefined' ? global :
|
|
typeof window !== 'undefined' ? window : {}
|
|
var minDoc = _dereq_('min-document');
|
|
|
|
if (typeof document !== 'undefined') {
|
|
module.exports = document;
|
|
} else {
|
|
var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
|
|
|
|
if (!doccy) {
|
|
doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
|
|
}
|
|
|
|
module.exports = doccy;
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9nbG9iYWwvZG9jdW1lbnQuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgdG9wTGV2ZWwgPSB0eXBlb2YgZ2xvYmFsICE9PSAndW5kZWZpbmVkJyA/IGdsb2JhbCA6XG4gICAgdHlwZW9mIHdpbmRvdyAhPT0gJ3VuZGVmaW5lZCcgPyB3aW5kb3cgOiB7fVxudmFyIG1pbkRvYyA9IHJlcXVpcmUoJ21pbi1kb2N1bWVudCcpO1xuXG5pZiAodHlwZW9mIGRvY3VtZW50ICE9PSAndW5kZWZpbmVkJykge1xuICAgIG1vZHVsZS5leHBvcnRzID0gZG9jdW1lbnQ7XG59IGVsc2Uge1xuICAgIHZhciBkb2NjeSA9IHRvcExldmVsWydfX0dMT0JBTF9ET0NVTUVOVF9DQUNIRUA0J107XG5cbiAgICBpZiAoIWRvY2N5KSB7XG4gICAgICAgIGRvY2N5ID0gdG9wTGV2ZWxbJ19fR0xPQkFMX0RPQ1VNRU5UX0NBQ0hFQDQnXSA9IG1pbkRvYztcbiAgICB9XG5cbiAgICBtb2R1bGUuZXhwb3J0cyA9IGRvY2N5O1xufVxuIl19
|
|
},{"min-document":3}],2:[function(_dereq_,module,exports){
|
|
(function (global){
|
|
if (typeof window !== "undefined") {
|
|
module.exports = window;
|
|
} else if (typeof global !== "undefined") {
|
|
module.exports = global;
|
|
} else if (typeof self !== "undefined"){
|
|
module.exports = self;
|
|
} else {
|
|
module.exports = {};
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9nbG9iYWwvd2luZG93LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsImZpbGUiOiJnZW5lcmF0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlc0NvbnRlbnQiOlsiaWYgKHR5cGVvZiB3aW5kb3cgIT09IFwidW5kZWZpbmVkXCIpIHtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHdpbmRvdztcbn0gZWxzZSBpZiAodHlwZW9mIGdsb2JhbCAhPT0gXCJ1bmRlZmluZWRcIikge1xuICAgIG1vZHVsZS5leHBvcnRzID0gZ2xvYmFsO1xufSBlbHNlIGlmICh0eXBlb2Ygc2VsZiAhPT0gXCJ1bmRlZmluZWRcIil7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBzZWxmO1xufSBlbHNlIHtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHt9O1xufVxuIl19
|
|
},{}],3:[function(_dereq_,module,exports){
|
|
|
|
},{}],4:[function(_dereq_,module,exports){
|
|
var getNative = _dereq_('../internal/getNative');
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeNow = getNative(Date, 'now');
|
|
|
|
/**
|
|
* Gets the number of milliseconds that have elapsed since the Unix epoch
|
|
* (1 January 1970 00:00:00 UTC).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Date
|
|
* @example
|
|
*
|
|
* _.defer(function(stamp) {
|
|
* console.log(_.now() - stamp);
|
|
* }, _.now());
|
|
* // => logs the number of milliseconds it took for the deferred function to be invoked
|
|
*/
|
|
var now = nativeNow || function() {
|
|
return new Date().getTime();
|
|
};
|
|
|
|
module.exports = now;
|
|
|
|
},{"../internal/getNative":20}],5:[function(_dereq_,module,exports){
|
|
var isObject = _dereq_('../lang/isObject'),
|
|
now = _dereq_('../date/now');
|
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max;
|
|
|
|
/**
|
|
* Creates a debounced function that delays invoking `func` until after `wait`
|
|
* milliseconds have elapsed since the last time the debounced function was
|
|
* invoked. The debounced function comes with a `cancel` method to cancel
|
|
* delayed invocations. Provide an options object to indicate that `func`
|
|
* should be invoked on the leading and/or trailing edge of the `wait` timeout.
|
|
* Subsequent calls to the debounced function return the result of the last
|
|
* `func` invocation.
|
|
*
|
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
|
|
* on the trailing edge of the timeout only if the the debounced function is
|
|
* invoked more than once during the `wait` timeout.
|
|
*
|
|
* See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
|
|
* for details over the differences between `_.debounce` and `_.throttle`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Function
|
|
* @param {Function} func The function to debounce.
|
|
* @param {number} [wait=0] The number of milliseconds to delay.
|
|
* @param {Object} [options] The options object.
|
|
* @param {boolean} [options.leading=false] Specify invoking on the leading
|
|
* edge of the timeout.
|
|
* @param {number} [options.maxWait] The maximum time `func` is allowed to be
|
|
* delayed before it's invoked.
|
|
* @param {boolean} [options.trailing=true] Specify invoking on the trailing
|
|
* edge of the timeout.
|
|
* @returns {Function} Returns the new debounced function.
|
|
* @example
|
|
*
|
|
* // avoid costly calculations while the window size is in flux
|
|
* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
|
|
*
|
|
* // invoke `sendMail` when the click event is fired, debouncing subsequent calls
|
|
* jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
|
|
* 'leading': true,
|
|
* 'trailing': false
|
|
* }));
|
|
*
|
|
* // ensure `batchLog` is invoked once after 1 second of debounced calls
|
|
* var source = new EventSource('/stream');
|
|
* jQuery(source).on('message', _.debounce(batchLog, 250, {
|
|
* 'maxWait': 1000
|
|
* }));
|
|
*
|
|
* // cancel a debounced call
|
|
* var todoChanges = _.debounce(batchLog, 1000);
|
|
* Object.observe(models.todo, todoChanges);
|
|
*
|
|
* Object.observe(models, function(changes) {
|
|
* if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
|
|
* todoChanges.cancel();
|
|
* }
|
|
* }, ['delete']);
|
|
*
|
|
* // ...at some point `models.todo` is changed
|
|
* models.todo.completed = true;
|
|
*
|
|
* // ...before 1 second has passed `models.todo` is deleted
|
|
* // which cancels the debounced `todoChanges` call
|
|
* delete models.todo;
|
|
*/
|
|
function debounce(func, wait, options) {
|
|
var args,
|
|
maxTimeoutId,
|
|
result,
|
|
stamp,
|
|
thisArg,
|
|
timeoutId,
|
|
trailingCall,
|
|
lastCalled = 0,
|
|
maxWait = false,
|
|
trailing = true;
|
|
|
|
if (typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
wait = wait < 0 ? 0 : (+wait || 0);
|
|
if (options === true) {
|
|
var leading = true;
|
|
trailing = false;
|
|
} else if (isObject(options)) {
|
|
leading = !!options.leading;
|
|
maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
|
|
trailing = 'trailing' in options ? !!options.trailing : trailing;
|
|
}
|
|
|
|
function cancel() {
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
if (maxTimeoutId) {
|
|
clearTimeout(maxTimeoutId);
|
|
}
|
|
lastCalled = 0;
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
}
|
|
|
|
function complete(isCalled, id) {
|
|
if (id) {
|
|
clearTimeout(id);
|
|
}
|
|
maxTimeoutId = timeoutId = trailingCall = undefined;
|
|
if (isCalled) {
|
|
lastCalled = now();
|
|
result = func.apply(thisArg, args);
|
|
if (!timeoutId && !maxTimeoutId) {
|
|
args = thisArg = undefined;
|
|
}
|
|
}
|
|
}
|
|
|
|
function delayed() {
|
|
var remaining = wait - (now() - stamp);
|
|
if (remaining <= 0 || remaining > wait) {
|
|
complete(trailingCall, maxTimeoutId);
|
|
} else {
|
|
timeoutId = setTimeout(delayed, remaining);
|
|
}
|
|
}
|
|
|
|
function maxDelayed() {
|
|
complete(trailing, timeoutId);
|
|
}
|
|
|
|
function debounced() {
|
|
args = arguments;
|
|
stamp = now();
|
|
thisArg = this;
|
|
trailingCall = trailing && (timeoutId || !leading);
|
|
|
|
if (maxWait === false) {
|
|
var leadingCall = leading && !timeoutId;
|
|
} else {
|
|
if (!maxTimeoutId && !leading) {
|
|
lastCalled = stamp;
|
|
}
|
|
var remaining = maxWait - (stamp - lastCalled),
|
|
isCalled = remaining <= 0 || remaining > maxWait;
|
|
|
|
if (isCalled) {
|
|
if (maxTimeoutId) {
|
|
maxTimeoutId = clearTimeout(maxTimeoutId);
|
|
}
|
|
lastCalled = stamp;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
else if (!maxTimeoutId) {
|
|
maxTimeoutId = setTimeout(maxDelayed, remaining);
|
|
}
|
|
}
|
|
if (isCalled && timeoutId) {
|
|
timeoutId = clearTimeout(timeoutId);
|
|
}
|
|
else if (!timeoutId && wait !== maxWait) {
|
|
timeoutId = setTimeout(delayed, wait);
|
|
}
|
|
if (leadingCall) {
|
|
isCalled = true;
|
|
result = func.apply(thisArg, args);
|
|
}
|
|
if (isCalled && !timeoutId && !maxTimeoutId) {
|
|
args = thisArg = undefined;
|
|
}
|
|
return result;
|
|
}
|
|
debounced.cancel = cancel;
|
|
return debounced;
|
|
}
|
|
|
|
module.exports = debounce;
|
|
|
|
},{"../date/now":4,"../lang/isObject":33}],6:[function(_dereq_,module,exports){
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max;
|
|
|
|
/**
|
|
* Creates a function that invokes `func` with the `this` binding of the
|
|
* created function and arguments from `start` and beyond provided as an array.
|
|
*
|
|
* **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Function
|
|
* @param {Function} func The function to apply a rest parameter to.
|
|
* @param {number} [start=func.length-1] The start position of the rest parameter.
|
|
* @returns {Function} Returns the new function.
|
|
* @example
|
|
*
|
|
* var say = _.restParam(function(what, names) {
|
|
* return what + ' ' + _.initial(names).join(', ') +
|
|
* (_.size(names) > 1 ? ', & ' : '') + _.last(names);
|
|
* });
|
|
*
|
|
* say('hello', 'fred', 'barney', 'pebbles');
|
|
* // => 'hello fred, barney, & pebbles'
|
|
*/
|
|
function restParam(func, start) {
|
|
if (typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
|
|
return function() {
|
|
var args = arguments,
|
|
index = -1,
|
|
length = nativeMax(args.length - start, 0),
|
|
rest = Array(length);
|
|
|
|
while (++index < length) {
|
|
rest[index] = args[start + index];
|
|
}
|
|
switch (start) {
|
|
case 0: return func.call(this, rest);
|
|
case 1: return func.call(this, args[0], rest);
|
|
case 2: return func.call(this, args[0], args[1], rest);
|
|
}
|
|
var otherArgs = Array(start + 1);
|
|
index = -1;
|
|
while (++index < start) {
|
|
otherArgs[index] = args[index];
|
|
}
|
|
otherArgs[start] = rest;
|
|
return func.apply(this, otherArgs);
|
|
};
|
|
}
|
|
|
|
module.exports = restParam;
|
|
|
|
},{}],7:[function(_dereq_,module,exports){
|
|
var debounce = _dereq_('./debounce'),
|
|
isObject = _dereq_('../lang/isObject');
|
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/**
|
|
* Creates a throttled function that only invokes `func` at most once per
|
|
* every `wait` milliseconds. The throttled function comes with a `cancel`
|
|
* method to cancel delayed invocations. Provide an options object to indicate
|
|
* that `func` should be invoked on the leading and/or trailing edge of the
|
|
* `wait` timeout. Subsequent calls to the throttled function return the
|
|
* result of the last `func` call.
|
|
*
|
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
|
|
* on the trailing edge of the timeout only if the the throttled function is
|
|
* invoked more than once during the `wait` timeout.
|
|
*
|
|
* See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
|
|
* for details over the differences between `_.throttle` and `_.debounce`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Function
|
|
* @param {Function} func The function to throttle.
|
|
* @param {number} [wait=0] The number of milliseconds to throttle invocations to.
|
|
* @param {Object} [options] The options object.
|
|
* @param {boolean} [options.leading=true] Specify invoking on the leading
|
|
* edge of the timeout.
|
|
* @param {boolean} [options.trailing=true] Specify invoking on the trailing
|
|
* edge of the timeout.
|
|
* @returns {Function} Returns the new throttled function.
|
|
* @example
|
|
*
|
|
* // avoid excessively updating the position while scrolling
|
|
* jQuery(window).on('scroll', _.throttle(updatePosition, 100));
|
|
*
|
|
* // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes
|
|
* jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
|
|
* 'trailing': false
|
|
* }));
|
|
*
|
|
* // cancel a trailing throttled call
|
|
* jQuery(window).on('popstate', throttled.cancel);
|
|
*/
|
|
function throttle(func, wait, options) {
|
|
var leading = true,
|
|
trailing = true;
|
|
|
|
if (typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
if (options === false) {
|
|
leading = false;
|
|
} else if (isObject(options)) {
|
|
leading = 'leading' in options ? !!options.leading : leading;
|
|
trailing = 'trailing' in options ? !!options.trailing : trailing;
|
|
}
|
|
return debounce(func, wait, { 'leading': leading, 'maxWait': +wait, 'trailing': trailing });
|
|
}
|
|
|
|
module.exports = throttle;
|
|
|
|
},{"../lang/isObject":33,"./debounce":5}],8:[function(_dereq_,module,exports){
|
|
/**
|
|
* Copies the values of `source` to `array`.
|
|
*
|
|
* @private
|
|
* @param {Array} source The array to copy values from.
|
|
* @param {Array} [array=[]] The array to copy values to.
|
|
* @returns {Array} Returns `array`.
|
|
*/
|
|
function arrayCopy(source, array) {
|
|
var index = -1,
|
|
length = source.length;
|
|
|
|
array || (array = Array(length));
|
|
while (++index < length) {
|
|
array[index] = source[index];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
module.exports = arrayCopy;
|
|
|
|
},{}],9:[function(_dereq_,module,exports){
|
|
/**
|
|
* A specialized version of `_.forEach` for arrays without support for callback
|
|
* shorthands and `this` binding.
|
|
*
|
|
* @private
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
* @returns {Array} Returns `array`.
|
|
*/
|
|
function arrayEach(array, iteratee) {
|
|
var index = -1,
|
|
length = array.length;
|
|
|
|
while (++index < length) {
|
|
if (iteratee(array[index], index, array) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
module.exports = arrayEach;
|
|
|
|
},{}],10:[function(_dereq_,module,exports){
|
|
/**
|
|
* Copies properties of `source` to `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} source The object to copy properties from.
|
|
* @param {Array} props The property names to copy.
|
|
* @param {Object} [object={}] The object to copy properties to.
|
|
* @returns {Object} Returns `object`.
|
|
*/
|
|
function baseCopy(source, props, object) {
|
|
object || (object = {});
|
|
|
|
var index = -1,
|
|
length = props.length;
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
object[key] = source[key];
|
|
}
|
|
return object;
|
|
}
|
|
|
|
module.exports = baseCopy;
|
|
|
|
},{}],11:[function(_dereq_,module,exports){
|
|
var createBaseFor = _dereq_('./createBaseFor');
|
|
|
|
/**
|
|
* The base implementation of `baseForIn` and `baseForOwn` which iterates
|
|
* over `object` properties returned by `keysFunc` invoking `iteratee` for
|
|
* each property. Iteratee functions may exit iteration early by explicitly
|
|
* returning `false`.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
* @param {Function} keysFunc The function to get the keys of `object`.
|
|
* @returns {Object} Returns `object`.
|
|
*/
|
|
var baseFor = createBaseFor();
|
|
|
|
module.exports = baseFor;
|
|
|
|
},{"./createBaseFor":18}],12:[function(_dereq_,module,exports){
|
|
var baseFor = _dereq_('./baseFor'),
|
|
keysIn = _dereq_('../object/keysIn');
|
|
|
|
/**
|
|
* The base implementation of `_.forIn` without support for callback
|
|
* shorthands and `this` binding.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to iterate over.
|
|
* @param {Function} iteratee The function invoked per iteration.
|
|
* @returns {Object} Returns `object`.
|
|
*/
|
|
function baseForIn(object, iteratee) {
|
|
return baseFor(object, iteratee, keysIn);
|
|
}
|
|
|
|
module.exports = baseForIn;
|
|
|
|
},{"../object/keysIn":39,"./baseFor":11}],13:[function(_dereq_,module,exports){
|
|
var arrayEach = _dereq_('./arrayEach'),
|
|
baseMergeDeep = _dereq_('./baseMergeDeep'),
|
|
isArray = _dereq_('../lang/isArray'),
|
|
isArrayLike = _dereq_('./isArrayLike'),
|
|
isObject = _dereq_('../lang/isObject'),
|
|
isObjectLike = _dereq_('./isObjectLike'),
|
|
isTypedArray = _dereq_('../lang/isTypedArray'),
|
|
keys = _dereq_('../object/keys');
|
|
|
|
/**
|
|
* The base implementation of `_.merge` without support for argument juggling,
|
|
* multiple sources, and `this` binding `customizer` functions.
|
|
*
|
|
* @private
|
|
* @param {Object} object The destination object.
|
|
* @param {Object} source The source object.
|
|
* @param {Function} [customizer] The function to customize merged values.
|
|
* @param {Array} [stackA=[]] Tracks traversed source objects.
|
|
* @param {Array} [stackB=[]] Associates values with source counterparts.
|
|
* @returns {Object} Returns `object`.
|
|
*/
|
|
function baseMerge(object, source, customizer, stackA, stackB) {
|
|
if (!isObject(object)) {
|
|
return object;
|
|
}
|
|
var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)),
|
|
props = isSrcArr ? undefined : keys(source);
|
|
|
|
arrayEach(props || source, function(srcValue, key) {
|
|
if (props) {
|
|
key = srcValue;
|
|
srcValue = source[key];
|
|
}
|
|
if (isObjectLike(srcValue)) {
|
|
stackA || (stackA = []);
|
|
stackB || (stackB = []);
|
|
baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);
|
|
}
|
|
else {
|
|
var value = object[key],
|
|
result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
|
|
isCommon = result === undefined;
|
|
|
|
if (isCommon) {
|
|
result = srcValue;
|
|
}
|
|
if ((result !== undefined || (isSrcArr && !(key in object))) &&
|
|
(isCommon || (result === result ? (result !== value) : (value === value)))) {
|
|
object[key] = result;
|
|
}
|
|
}
|
|
});
|
|
return object;
|
|
}
|
|
|
|
module.exports = baseMerge;
|
|
|
|
},{"../lang/isArray":30,"../lang/isObject":33,"../lang/isTypedArray":36,"../object/keys":38,"./arrayEach":9,"./baseMergeDeep":14,"./isArrayLike":21,"./isObjectLike":26}],14:[function(_dereq_,module,exports){
|
|
var arrayCopy = _dereq_('./arrayCopy'),
|
|
isArguments = _dereq_('../lang/isArguments'),
|
|
isArray = _dereq_('../lang/isArray'),
|
|
isArrayLike = _dereq_('./isArrayLike'),
|
|
isPlainObject = _dereq_('../lang/isPlainObject'),
|
|
isTypedArray = _dereq_('../lang/isTypedArray'),
|
|
toPlainObject = _dereq_('../lang/toPlainObject');
|
|
|
|
/**
|
|
* A specialized version of `baseMerge` for arrays and objects which performs
|
|
* deep merges and tracks traversed objects enabling objects with circular
|
|
* references to be merged.
|
|
*
|
|
* @private
|
|
* @param {Object} object The destination object.
|
|
* @param {Object} source The source object.
|
|
* @param {string} key The key of the value to merge.
|
|
* @param {Function} mergeFunc The function to merge values.
|
|
* @param {Function} [customizer] The function to customize merged values.
|
|
* @param {Array} [stackA=[]] Tracks traversed source objects.
|
|
* @param {Array} [stackB=[]] Associates values with source counterparts.
|
|
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
|
*/
|
|
function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {
|
|
var length = stackA.length,
|
|
srcValue = source[key];
|
|
|
|
while (length--) {
|
|
if (stackA[length] == srcValue) {
|
|
object[key] = stackB[length];
|
|
return;
|
|
}
|
|
}
|
|
var value = object[key],
|
|
result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
|
|
isCommon = result === undefined;
|
|
|
|
if (isCommon) {
|
|
result = srcValue;
|
|
if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {
|
|
result = isArray(value)
|
|
? value
|
|
: (isArrayLike(value) ? arrayCopy(value) : []);
|
|
}
|
|
else if (isPlainObject(srcValue) || isArguments(srcValue)) {
|
|
result = isArguments(value)
|
|
? toPlainObject(value)
|
|
: (isPlainObject(value) ? value : {});
|
|
}
|
|
else {
|
|
isCommon = false;
|
|
}
|
|
}
|
|
// Add the source value to the stack of traversed objects and associate
|
|
// it with its merged value.
|
|
stackA.push(srcValue);
|
|
stackB.push(result);
|
|
|
|
if (isCommon) {
|
|
// Recursively merge objects and arrays (susceptible to call stack limits).
|
|
object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);
|
|
} else if (result === result ? (result !== value) : (value === value)) {
|
|
object[key] = result;
|
|
}
|
|
}
|
|
|
|
module.exports = baseMergeDeep;
|
|
|
|
},{"../lang/isArguments":29,"../lang/isArray":30,"../lang/isPlainObject":34,"../lang/isTypedArray":36,"../lang/toPlainObject":37,"./arrayCopy":8,"./isArrayLike":21}],15:[function(_dereq_,module,exports){
|
|
var toObject = _dereq_('./toObject');
|
|
|
|
/**
|
|
* The base implementation of `_.property` without support for deep paths.
|
|
*
|
|
* @private
|
|
* @param {string} key The key of the property to get.
|
|
* @returns {Function} Returns the new function.
|
|
*/
|
|
function baseProperty(key) {
|
|
return function(object) {
|
|
return object == null ? undefined : toObject(object)[key];
|
|
};
|
|
}
|
|
|
|
module.exports = baseProperty;
|
|
|
|
},{"./toObject":28}],16:[function(_dereq_,module,exports){
|
|
var identity = _dereq_('../utility/identity');
|
|
|
|
/**
|
|
* A specialized version of `baseCallback` which only supports `this` binding
|
|
* and specifying the number of arguments to provide to `func`.
|
|
*
|
|
* @private
|
|
* @param {Function} func The function to bind.
|
|
* @param {*} thisArg The `this` binding of `func`.
|
|
* @param {number} [argCount] The number of arguments to provide to `func`.
|
|
* @returns {Function} Returns the callback.
|
|
*/
|
|
function bindCallback(func, thisArg, argCount) {
|
|
if (typeof func != 'function') {
|
|
return identity;
|
|
}
|
|
if (thisArg === undefined) {
|
|
return func;
|
|
}
|
|
switch (argCount) {
|
|
case 1: return function(value) {
|
|
return func.call(thisArg, value);
|
|
};
|
|
case 3: return function(value, index, collection) {
|
|
return func.call(thisArg, value, index, collection);
|
|
};
|
|
case 4: return function(accumulator, value, index, collection) {
|
|
return func.call(thisArg, accumulator, value, index, collection);
|
|
};
|
|
case 5: return function(value, other, key, object, source) {
|
|
return func.call(thisArg, value, other, key, object, source);
|
|
};
|
|
}
|
|
return function() {
|
|
return func.apply(thisArg, arguments);
|
|
};
|
|
}
|
|
|
|
module.exports = bindCallback;
|
|
|
|
},{"../utility/identity":42}],17:[function(_dereq_,module,exports){
|
|
var bindCallback = _dereq_('./bindCallback'),
|
|
isIterateeCall = _dereq_('./isIterateeCall'),
|
|
restParam = _dereq_('../function/restParam');
|
|
|
|
/**
|
|
* Creates a `_.assign`, `_.defaults`, or `_.merge` function.
|
|
*
|
|
* @private
|
|
* @param {Function} assigner The function to assign values.
|
|
* @returns {Function} Returns the new assigner function.
|
|
*/
|
|
function createAssigner(assigner) {
|
|
return restParam(function(object, sources) {
|
|
var index = -1,
|
|
length = object == null ? 0 : sources.length,
|
|
customizer = length > 2 ? sources[length - 2] : undefined,
|
|
guard = length > 2 ? sources[2] : undefined,
|
|
thisArg = length > 1 ? sources[length - 1] : undefined;
|
|
|
|
if (typeof customizer == 'function') {
|
|
customizer = bindCallback(customizer, thisArg, 5);
|
|
length -= 2;
|
|
} else {
|
|
customizer = typeof thisArg == 'function' ? thisArg : undefined;
|
|
length -= (customizer ? 1 : 0);
|
|
}
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
|
customizer = length < 3 ? undefined : customizer;
|
|
length = 1;
|
|
}
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
if (source) {
|
|
assigner(object, source, customizer);
|
|
}
|
|
}
|
|
return object;
|
|
});
|
|
}
|
|
|
|
module.exports = createAssigner;
|
|
|
|
},{"../function/restParam":6,"./bindCallback":16,"./isIterateeCall":24}],18:[function(_dereq_,module,exports){
|
|
var toObject = _dereq_('./toObject');
|
|
|
|
/**
|
|
* Creates a base function for `_.forIn` or `_.forInRight`.
|
|
*
|
|
* @private
|
|
* @param {boolean} [fromRight] Specify iterating from right to left.
|
|
* @returns {Function} Returns the new base function.
|
|
*/
|
|
function createBaseFor(fromRight) {
|
|
return function(object, iteratee, keysFunc) {
|
|
var iterable = toObject(object),
|
|
props = keysFunc(object),
|
|
length = props.length,
|
|
index = fromRight ? length : -1;
|
|
|
|
while ((fromRight ? index-- : ++index < length)) {
|
|
var key = props[index];
|
|
if (iteratee(iterable[key], key, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
}
|
|
|
|
module.exports = createBaseFor;
|
|
|
|
},{"./toObject":28}],19:[function(_dereq_,module,exports){
|
|
var baseProperty = _dereq_('./baseProperty');
|
|
|
|
/**
|
|
* Gets the "length" property value of `object`.
|
|
*
|
|
* **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
|
|
* that affects Safari on at least iOS 8.1-8.3 ARM64.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to query.
|
|
* @returns {*} Returns the "length" value.
|
|
*/
|
|
var getLength = baseProperty('length');
|
|
|
|
module.exports = getLength;
|
|
|
|
},{"./baseProperty":15}],20:[function(_dereq_,module,exports){
|
|
var isNative = _dereq_('../lang/isNative');
|
|
|
|
/**
|
|
* Gets the native function at `key` of `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to query.
|
|
* @param {string} key The key of the method to get.
|
|
* @returns {*} Returns the function if it's native, else `undefined`.
|
|
*/
|
|
function getNative(object, key) {
|
|
var value = object == null ? undefined : object[key];
|
|
return isNative(value) ? value : undefined;
|
|
}
|
|
|
|
module.exports = getNative;
|
|
|
|
},{"../lang/isNative":32}],21:[function(_dereq_,module,exports){
|
|
var getLength = _dereq_('./getLength'),
|
|
isLength = _dereq_('./isLength');
|
|
|
|
/**
|
|
* Checks if `value` is array-like.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
|
*/
|
|
function isArrayLike(value) {
|
|
return value != null && isLength(getLength(value));
|
|
}
|
|
|
|
module.exports = isArrayLike;
|
|
|
|
},{"./getLength":19,"./isLength":25}],22:[function(_dereq_,module,exports){
|
|
/**
|
|
* Checks if `value` is a host object in IE < 9.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
|
|
*/
|
|
var isHostObject = (function() {
|
|
try {
|
|
Object({ 'toString': 0 } + '');
|
|
} catch(e) {
|
|
return function() { return false; };
|
|
}
|
|
return function(value) {
|
|
// IE < 9 presents many host objects as `Object` objects that can coerce
|
|
// to strings despite having improperly defined `toString` methods.
|
|
return typeof value.toString != 'function' && typeof (value + '') == 'string';
|
|
};
|
|
}());
|
|
|
|
module.exports = isHostObject;
|
|
|
|
},{}],23:[function(_dereq_,module,exports){
|
|
/** Used to detect unsigned integer values. */
|
|
var reIsUint = /^\d+$/;
|
|
|
|
/**
|
|
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
|
* of an array-like value.
|
|
*/
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
|
|
/**
|
|
* Checks if `value` is a valid array-like index.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
|
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
|
*/
|
|
function isIndex(value, length) {
|
|
value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return value > -1 && value % 1 == 0 && value < length;
|
|
}
|
|
|
|
module.exports = isIndex;
|
|
|
|
},{}],24:[function(_dereq_,module,exports){
|
|
var isArrayLike = _dereq_('./isArrayLike'),
|
|
isIndex = _dereq_('./isIndex'),
|
|
isObject = _dereq_('../lang/isObject');
|
|
|
|
/**
|
|
* Checks if the provided arguments are from an iteratee call.
|
|
*
|
|
* @private
|
|
* @param {*} value The potential iteratee value argument.
|
|
* @param {*} index The potential iteratee index or key argument.
|
|
* @param {*} object The potential iteratee object argument.
|
|
* @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
|
|
*/
|
|
function isIterateeCall(value, index, object) {
|
|
if (!isObject(object)) {
|
|
return false;
|
|
}
|
|
var type = typeof index;
|
|
if (type == 'number'
|
|
? (isArrayLike(object) && isIndex(index, object.length))
|
|
: (type == 'string' && index in object)) {
|
|
var other = object[index];
|
|
return value === value ? (value === other) : (other !== other);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
module.exports = isIterateeCall;
|
|
|
|
},{"../lang/isObject":33,"./isArrayLike":21,"./isIndex":23}],25:[function(_dereq_,module,exports){
|
|
/**
|
|
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
|
* of an array-like value.
|
|
*/
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
|
|
/**
|
|
* Checks if `value` is a valid array-like length.
|
|
*
|
|
* **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
|
*/
|
|
function isLength(value) {
|
|
return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
}
|
|
|
|
module.exports = isLength;
|
|
|
|
},{}],26:[function(_dereq_,module,exports){
|
|
/**
|
|
* Checks if `value` is object-like.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
|
*/
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == 'object';
|
|
}
|
|
|
|
module.exports = isObjectLike;
|
|
|
|
},{}],27:[function(_dereq_,module,exports){
|
|
var isArguments = _dereq_('../lang/isArguments'),
|
|
isArray = _dereq_('../lang/isArray'),
|
|
isIndex = _dereq_('./isIndex'),
|
|
isLength = _dereq_('./isLength'),
|
|
isString = _dereq_('../lang/isString'),
|
|
keysIn = _dereq_('../object/keysIn');
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* A fallback implementation of `Object.keys` which creates an array of the
|
|
* own enumerable property names of `object`.
|
|
*
|
|
* @private
|
|
* @param {Object} object The object to query.
|
|
* @returns {Array} Returns the array of property names.
|
|
*/
|
|
function shimKeys(object) {
|
|
var props = keysIn(object),
|
|
propsLength = props.length,
|
|
length = propsLength && object.length;
|
|
|
|
var allowIndexes = !!length && isLength(length) &&
|
|
(isArray(object) || isArguments(object) || isString(object));
|
|
|
|
var index = -1,
|
|
result = [];
|
|
|
|
while (++index < propsLength) {
|
|
var key = props[index];
|
|
if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
module.exports = shimKeys;
|
|
|
|
},{"../lang/isArguments":29,"../lang/isArray":30,"../lang/isString":35,"../object/keysIn":39,"./isIndex":23,"./isLength":25}],28:[function(_dereq_,module,exports){
|
|
var isObject = _dereq_('../lang/isObject'),
|
|
isString = _dereq_('../lang/isString'),
|
|
support = _dereq_('../support');
|
|
|
|
/**
|
|
* Converts `value` to an object if it's not one.
|
|
*
|
|
* @private
|
|
* @param {*} value The value to process.
|
|
* @returns {Object} Returns the object.
|
|
*/
|
|
function toObject(value) {
|
|
if (support.unindexedChars && isString(value)) {
|
|
var index = -1,
|
|
length = value.length,
|
|
result = Object(value);
|
|
|
|
while (++index < length) {
|
|
result[index] = value.charAt(index);
|
|
}
|
|
return result;
|
|
}
|
|
return isObject(value) ? value : Object(value);
|
|
}
|
|
|
|
module.exports = toObject;
|
|
|
|
},{"../lang/isObject":33,"../lang/isString":35,"../support":41}],29:[function(_dereq_,module,exports){
|
|
var isArrayLike = _dereq_('../internal/isArrayLike'),
|
|
isObjectLike = _dereq_('../internal/isObjectLike');
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/** Native method references. */
|
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
|
|
|
/**
|
|
* Checks if `value` is classified as an `arguments` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isArguments(function() { return arguments; }());
|
|
* // => true
|
|
*
|
|
* _.isArguments([1, 2, 3]);
|
|
* // => false
|
|
*/
|
|
function isArguments(value) {
|
|
return isObjectLike(value) && isArrayLike(value) &&
|
|
hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
|
|
}
|
|
|
|
module.exports = isArguments;
|
|
|
|
},{"../internal/isArrayLike":21,"../internal/isObjectLike":26}],30:[function(_dereq_,module,exports){
|
|
var getNative = _dereq_('../internal/getNative'),
|
|
isLength = _dereq_('../internal/isLength'),
|
|
isObjectLike = _dereq_('../internal/isObjectLike');
|
|
|
|
/** `Object#toString` result references. */
|
|
var arrayTag = '[object Array]';
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeIsArray = getNative(Array, 'isArray');
|
|
|
|
/**
|
|
* Checks if `value` is classified as an `Array` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isArray([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isArray(function() { return arguments; }());
|
|
* // => false
|
|
*/
|
|
var isArray = nativeIsArray || function(value) {
|
|
return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
|
|
};
|
|
|
|
module.exports = isArray;
|
|
|
|
},{"../internal/getNative":20,"../internal/isLength":25,"../internal/isObjectLike":26}],31:[function(_dereq_,module,exports){
|
|
var isObject = _dereq_('./isObject');
|
|
|
|
/** `Object#toString` result references. */
|
|
var funcTag = '[object Function]';
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `Function` object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isFunction(_);
|
|
* // => true
|
|
*
|
|
* _.isFunction(/abc/);
|
|
* // => false
|
|
*/
|
|
function isFunction(value) {
|
|
// The use of `Object#toString` avoids issues with the `typeof` operator
|
|
// in older versions of Chrome and Safari which return 'function' for regexes
|
|
// and Safari 8 which returns 'object' for typed array constructors.
|
|
return isObject(value) && objToString.call(value) == funcTag;
|
|
}
|
|
|
|
module.exports = isFunction;
|
|
|
|
},{"./isObject":33}],32:[function(_dereq_,module,exports){
|
|
var isFunction = _dereq_('./isFunction'),
|
|
isHostObject = _dereq_('../internal/isHostObject'),
|
|
isObjectLike = _dereq_('../internal/isObjectLike');
|
|
|
|
/** Used to detect host constructors (Safari > 5). */
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to resolve the decompiled source of functions. */
|
|
var fnToString = Function.prototype.toString;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/** Used to detect if a method is native. */
|
|
var reIsNative = RegExp('^' +
|
|
fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
);
|
|
|
|
/**
|
|
* Checks if `value` is a native function.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
|
|
* @example
|
|
*
|
|
* _.isNative(Array.prototype.push);
|
|
* // => true
|
|
*
|
|
* _.isNative(_);
|
|
* // => false
|
|
*/
|
|
function isNative(value) {
|
|
if (value == null) {
|
|
return false;
|
|
}
|
|
if (isFunction(value)) {
|
|
return reIsNative.test(fnToString.call(value));
|
|
}
|
|
return isObjectLike(value) && (isHostObject(value) ? reIsNative : reIsHostCtor).test(value);
|
|
}
|
|
|
|
module.exports = isNative;
|
|
|
|
},{"../internal/isHostObject":22,"../internal/isObjectLike":26,"./isFunction":31}],33:[function(_dereq_,module,exports){
|
|
/**
|
|
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
|
|
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(1);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
// Avoid a V8 JIT bug in Chrome 19-20.
|
|
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
|
|
var type = typeof value;
|
|
return !!value && (type == 'object' || type == 'function');
|
|
}
|
|
|
|
module.exports = isObject;
|
|
|
|
},{}],34:[function(_dereq_,module,exports){
|
|
var baseForIn = _dereq_('../internal/baseForIn'),
|
|
isArguments = _dereq_('./isArguments'),
|
|
isHostObject = _dereq_('../internal/isHostObject'),
|
|
isObjectLike = _dereq_('../internal/isObjectLike'),
|
|
support = _dereq_('../support');
|
|
|
|
/** `Object#toString` result references. */
|
|
var objectTag = '[object Object]';
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/**
|
|
* Checks if `value` is a plain object, that is, an object created by the
|
|
* `Object` constructor or one with a `[[Prototype]]` of `null`.
|
|
*
|
|
* **Note:** This method assumes objects created by the `Object` constructor
|
|
* have no inherited enumerable properties.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
|
|
* @example
|
|
*
|
|
* function Foo() {
|
|
* this.a = 1;
|
|
* }
|
|
*
|
|
* _.isPlainObject(new Foo);
|
|
* // => false
|
|
*
|
|
* _.isPlainObject([1, 2, 3]);
|
|
* // => false
|
|
*
|
|
* _.isPlainObject({ 'x': 0, 'y': 0 });
|
|
* // => true
|
|
*
|
|
* _.isPlainObject(Object.create(null));
|
|
* // => true
|
|
*/
|
|
function isPlainObject(value) {
|
|
var Ctor;
|
|
|
|
// Exit early for non `Object` objects.
|
|
if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isHostObject(value) && !isArguments(value)) ||
|
|
(!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
|
|
return false;
|
|
}
|
|
// IE < 9 iterates inherited properties before own properties. If the first
|
|
// iterated property is an object's own property then there are no inherited
|
|
// enumerable properties.
|
|
var result;
|
|
if (support.ownLast) {
|
|
baseForIn(value, function(subValue, key, object) {
|
|
result = hasOwnProperty.call(object, key);
|
|
return false;
|
|
});
|
|
return result !== false;
|
|
}
|
|
// In most environments an object's own properties are iterated before
|
|
// its inherited properties. If the last iterated property is an object's
|
|
// own property then there are no inherited enumerable properties.
|
|
baseForIn(value, function(subValue, key) {
|
|
result = key;
|
|
});
|
|
return result === undefined || hasOwnProperty.call(value, result);
|
|
}
|
|
|
|
module.exports = isPlainObject;
|
|
|
|
},{"../internal/baseForIn":12,"../internal/isHostObject":22,"../internal/isObjectLike":26,"../support":41,"./isArguments":29}],35:[function(_dereq_,module,exports){
|
|
var isObjectLike = _dereq_('../internal/isObjectLike');
|
|
|
|
/** `Object#toString` result references. */
|
|
var stringTag = '[object String]';
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `String` primitive or object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isString('abc');
|
|
* // => true
|
|
*
|
|
* _.isString(1);
|
|
* // => false
|
|
*/
|
|
function isString(value) {
|
|
return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);
|
|
}
|
|
|
|
module.exports = isString;
|
|
|
|
},{"../internal/isObjectLike":26}],36:[function(_dereq_,module,exports){
|
|
var isLength = _dereq_('../internal/isLength'),
|
|
isObjectLike = _dereq_('../internal/isObjectLike');
|
|
|
|
/** `Object#toString` result references. */
|
|
var argsTag = '[object Arguments]',
|
|
arrayTag = '[object Array]',
|
|
boolTag = '[object Boolean]',
|
|
dateTag = '[object Date]',
|
|
errorTag = '[object Error]',
|
|
funcTag = '[object Function]',
|
|
mapTag = '[object Map]',
|
|
numberTag = '[object Number]',
|
|
objectTag = '[object Object]',
|
|
regexpTag = '[object RegExp]',
|
|
setTag = '[object Set]',
|
|
stringTag = '[object String]',
|
|
weakMapTag = '[object WeakMap]';
|
|
|
|
var arrayBufferTag = '[object ArrayBuffer]',
|
|
float32Tag = '[object Float32Array]',
|
|
float64Tag = '[object Float64Array]',
|
|
int8Tag = '[object Int8Array]',
|
|
int16Tag = '[object Int16Array]',
|
|
int32Tag = '[object Int32Array]',
|
|
uint8Tag = '[object Uint8Array]',
|
|
uint8ClampedTag = '[object Uint8ClampedArray]',
|
|
uint16Tag = '[object Uint16Array]',
|
|
uint32Tag = '[object Uint32Array]';
|
|
|
|
/** Used to identify `toStringTag` values of typed arrays. */
|
|
var typedArrayTags = {};
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
|
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
|
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
|
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
|
typedArrayTags[uint32Tag] = true;
|
|
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
|
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
|
typedArrayTags[dateTag] = typedArrayTags[errorTag] =
|
|
typedArrayTags[funcTag] = typedArrayTags[mapTag] =
|
|
typedArrayTags[numberTag] = typedArrayTags[objectTag] =
|
|
typedArrayTags[regexpTag] = typedArrayTags[setTag] =
|
|
typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
|
|
|
/** Used for native method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/**
|
|
* Checks if `value` is classified as a typed array.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
|
* @example
|
|
*
|
|
* _.isTypedArray(new Uint8Array);
|
|
* // => true
|
|
*
|
|
* _.isTypedArray([]);
|
|
* // => false
|
|
*/
|
|
function isTypedArray(value) {
|
|
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
|
|
}
|
|
|
|
module.exports = isTypedArray;
|
|
|
|
},{"../internal/isLength":25,"../internal/isObjectLike":26}],37:[function(_dereq_,module,exports){
|
|
var baseCopy = _dereq_('../internal/baseCopy'),
|
|
keysIn = _dereq_('../object/keysIn');
|
|
|
|
/**
|
|
* Converts `value` to a plain object flattening inherited enumerable
|
|
* properties of `value` to own properties of the plain object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Lang
|
|
* @param {*} value The value to convert.
|
|
* @returns {Object} Returns the converted plain object.
|
|
* @example
|
|
*
|
|
* function Foo() {
|
|
* this.b = 2;
|
|
* }
|
|
*
|
|
* Foo.prototype.c = 3;
|
|
*
|
|
* _.assign({ 'a': 1 }, new Foo);
|
|
* // => { 'a': 1, 'b': 2 }
|
|
*
|
|
* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
|
|
* // => { 'a': 1, 'b': 2, 'c': 3 }
|
|
*/
|
|
function toPlainObject(value) {
|
|
return baseCopy(value, keysIn(value));
|
|
}
|
|
|
|
module.exports = toPlainObject;
|
|
|
|
},{"../internal/baseCopy":10,"../object/keysIn":39}],38:[function(_dereq_,module,exports){
|
|
var getNative = _dereq_('../internal/getNative'),
|
|
isArrayLike = _dereq_('../internal/isArrayLike'),
|
|
isObject = _dereq_('../lang/isObject'),
|
|
shimKeys = _dereq_('../internal/shimKeys'),
|
|
support = _dereq_('../support');
|
|
|
|
/* Native method references for those with the same name as other `lodash` methods. */
|
|
var nativeKeys = getNative(Object, 'keys');
|
|
|
|
/**
|
|
* Creates an array of the own enumerable property names of `object`.
|
|
*
|
|
* **Note:** Non-object values are coerced to objects. See the
|
|
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
|
|
* for more details.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Object
|
|
* @param {Object} object The object to query.
|
|
* @returns {Array} Returns the array of property names.
|
|
* @example
|
|
*
|
|
* function Foo() {
|
|
* this.a = 1;
|
|
* this.b = 2;
|
|
* }
|
|
*
|
|
* Foo.prototype.c = 3;
|
|
*
|
|
* _.keys(new Foo);
|
|
* // => ['a', 'b'] (iteration order is not guaranteed)
|
|
*
|
|
* _.keys('hi');
|
|
* // => ['0', '1']
|
|
*/
|
|
var keys = !nativeKeys ? shimKeys : function(object) {
|
|
var Ctor = object == null ? undefined : object.constructor;
|
|
if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
|
|
(typeof object == 'function' ? support.enumPrototypes : isArrayLike(object))) {
|
|
return shimKeys(object);
|
|
}
|
|
return isObject(object) ? nativeKeys(object) : [];
|
|
};
|
|
|
|
module.exports = keys;
|
|
|
|
},{"../internal/getNative":20,"../internal/isArrayLike":21,"../internal/shimKeys":27,"../lang/isObject":33,"../support":41}],39:[function(_dereq_,module,exports){
|
|
var arrayEach = _dereq_('../internal/arrayEach'),
|
|
isArguments = _dereq_('../lang/isArguments'),
|
|
isArray = _dereq_('../lang/isArray'),
|
|
isFunction = _dereq_('../lang/isFunction'),
|
|
isIndex = _dereq_('../internal/isIndex'),
|
|
isLength = _dereq_('../internal/isLength'),
|
|
isObject = _dereq_('../lang/isObject'),
|
|
isString = _dereq_('../lang/isString'),
|
|
support = _dereq_('../support');
|
|
|
|
/** `Object#toString` result references. */
|
|
var arrayTag = '[object Array]',
|
|
boolTag = '[object Boolean]',
|
|
dateTag = '[object Date]',
|
|
errorTag = '[object Error]',
|
|
funcTag = '[object Function]',
|
|
numberTag = '[object Number]',
|
|
objectTag = '[object Object]',
|
|
regexpTag = '[object RegExp]',
|
|
stringTag = '[object String]';
|
|
|
|
/** Used to fix the JScript `[[DontEnum]]` bug. */
|
|
var shadowProps = [
|
|
'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
|
|
'toLocaleString', 'toString', 'valueOf'
|
|
];
|
|
|
|
/** Used for native method references. */
|
|
var errorProto = Error.prototype,
|
|
objectProto = Object.prototype,
|
|
stringProto = String.prototype;
|
|
|
|
/** Used to check objects for own properties. */
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
|
|
/**
|
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objToString = objectProto.toString;
|
|
|
|
/** Used to avoid iterating over non-enumerable properties in IE < 9. */
|
|
var nonEnumProps = {};
|
|
nonEnumProps[arrayTag] = nonEnumProps[dateTag] = nonEnumProps[numberTag] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };
|
|
nonEnumProps[boolTag] = nonEnumProps[stringTag] = { 'constructor': true, 'toString': true, 'valueOf': true };
|
|
nonEnumProps[errorTag] = nonEnumProps[funcTag] = nonEnumProps[regexpTag] = { 'constructor': true, 'toString': true };
|
|
nonEnumProps[objectTag] = { 'constructor': true };
|
|
|
|
arrayEach(shadowProps, function(key) {
|
|
for (var tag in nonEnumProps) {
|
|
if (hasOwnProperty.call(nonEnumProps, tag)) {
|
|
var props = nonEnumProps[tag];
|
|
props[key] = hasOwnProperty.call(props, key);
|
|
}
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Creates an array of the own and inherited enumerable property names of `object`.
|
|
*
|
|
* **Note:** Non-object values are coerced to objects.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Object
|
|
* @param {Object} object The object to query.
|
|
* @returns {Array} Returns the array of property names.
|
|
* @example
|
|
*
|
|
* function Foo() {
|
|
* this.a = 1;
|
|
* this.b = 2;
|
|
* }
|
|
*
|
|
* Foo.prototype.c = 3;
|
|
*
|
|
* _.keysIn(new Foo);
|
|
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
|
|
*/
|
|
function keysIn(object) {
|
|
if (object == null) {
|
|
return [];
|
|
}
|
|
if (!isObject(object)) {
|
|
object = Object(object);
|
|
}
|
|
var length = object.length;
|
|
|
|
length = (length && isLength(length) &&
|
|
(isArray(object) || isArguments(object) || isString(object)) && length) || 0;
|
|
|
|
var Ctor = object.constructor,
|
|
index = -1,
|
|
proto = (isFunction(Ctor) && Ctor.prototype) || objectProto,
|
|
isProto = proto === object,
|
|
result = Array(length),
|
|
skipIndexes = length > 0,
|
|
skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error),
|
|
skipProto = support.enumPrototypes && isFunction(object);
|
|
|
|
while (++index < length) {
|
|
result[index] = (index + '');
|
|
}
|
|
// lodash skips the `constructor` property when it infers it's iterating
|
|
// over a `prototype` object because IE < 9 can't set the `[[Enumerable]]`
|
|
// attribute of an existing property and the `constructor` property of a
|
|
// prototype defaults to non-enumerable.
|
|
for (var key in object) {
|
|
if (!(skipProto && key == 'prototype') &&
|
|
!(skipErrorProps && (key == 'message' || key == 'name')) &&
|
|
!(skipIndexes && isIndex(key, length)) &&
|
|
!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
if (support.nonEnumShadows && object !== objectProto) {
|
|
var tag = object === stringProto ? stringTag : (object === errorProto ? errorTag : objToString.call(object)),
|
|
nonEnums = nonEnumProps[tag] || nonEnumProps[objectTag];
|
|
|
|
if (tag == objectTag) {
|
|
proto = objectProto;
|
|
}
|
|
length = shadowProps.length;
|
|
while (length--) {
|
|
key = shadowProps[length];
|
|
var nonEnum = nonEnums[key];
|
|
if (!(isProto && nonEnum) &&
|
|
(nonEnum ? hasOwnProperty.call(object, key) : object[key] !== proto[key])) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
module.exports = keysIn;
|
|
|
|
},{"../internal/arrayEach":9,"../internal/isIndex":23,"../internal/isLength":25,"../lang/isArguments":29,"../lang/isArray":30,"../lang/isFunction":31,"../lang/isObject":33,"../lang/isString":35,"../support":41}],40:[function(_dereq_,module,exports){
|
|
var baseMerge = _dereq_('../internal/baseMerge'),
|
|
createAssigner = _dereq_('../internal/createAssigner');
|
|
|
|
/**
|
|
* Recursively merges own enumerable properties of the source object(s), that
|
|
* don't resolve to `undefined` into the destination object. Subsequent sources
|
|
* overwrite property assignments of previous sources. If `customizer` is
|
|
* provided it's invoked to produce the merged values of the destination and
|
|
* source properties. If `customizer` returns `undefined` merging is handled
|
|
* by the method instead. The `customizer` is bound to `thisArg` and invoked
|
|
* with five arguments: (objectValue, sourceValue, key, object, source).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Object
|
|
* @param {Object} object The destination object.
|
|
* @param {...Object} [sources] The source objects.
|
|
* @param {Function} [customizer] The function to customize assigned values.
|
|
* @param {*} [thisArg] The `this` binding of `customizer`.
|
|
* @returns {Object} Returns `object`.
|
|
* @example
|
|
*
|
|
* var users = {
|
|
* 'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
|
|
* };
|
|
*
|
|
* var ages = {
|
|
* 'data': [{ 'age': 36 }, { 'age': 40 }]
|
|
* };
|
|
*
|
|
* _.merge(users, ages);
|
|
* // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
|
|
*
|
|
* // using a customizer callback
|
|
* var object = {
|
|
* 'fruits': ['apple'],
|
|
* 'vegetables': ['beet']
|
|
* };
|
|
*
|
|
* var other = {
|
|
* 'fruits': ['banana'],
|
|
* 'vegetables': ['carrot']
|
|
* };
|
|
*
|
|
* _.merge(object, other, function(a, b) {
|
|
* if (_.isArray(a)) {
|
|
* return a.concat(b);
|
|
* }
|
|
* });
|
|
* // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
|
|
*/
|
|
var merge = createAssigner(baseMerge);
|
|
|
|
module.exports = merge;
|
|
|
|
},{"../internal/baseMerge":13,"../internal/createAssigner":17}],41:[function(_dereq_,module,exports){
|
|
/** Used for native method references. */
|
|
var arrayProto = Array.prototype,
|
|
errorProto = Error.prototype,
|
|
objectProto = Object.prototype;
|
|
|
|
/** Native method references. */
|
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable,
|
|
splice = arrayProto.splice;
|
|
|
|
/**
|
|
* An object environment feature flags.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @type Object
|
|
*/
|
|
var support = {};
|
|
|
|
(function(x) {
|
|
var Ctor = function() { this.x = x; },
|
|
object = { '0': x, 'length': x },
|
|
props = [];
|
|
|
|
Ctor.prototype = { 'valueOf': x, 'y': x };
|
|
for (var key in new Ctor) { props.push(key); }
|
|
|
|
/**
|
|
* Detect if `name` or `message` properties of `Error.prototype` are
|
|
* enumerable by default (IE < 9, Safari < 5.1).
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') ||
|
|
propertyIsEnumerable.call(errorProto, 'name');
|
|
|
|
/**
|
|
* Detect if `prototype` properties are enumerable by default.
|
|
*
|
|
* Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
|
|
* (if the prototype or a property on the prototype has been set)
|
|
* incorrectly set the `[[Enumerable]]` value of a function's `prototype`
|
|
* property to `true`.
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.enumPrototypes = propertyIsEnumerable.call(Ctor, 'prototype');
|
|
|
|
/**
|
|
* Detect if properties shadowing those on `Object.prototype` are non-enumerable.
|
|
*
|
|
* In IE < 9 an object's own properties, shadowing non-enumerable ones,
|
|
* are made non-enumerable as well (a.k.a the JScript `[[DontEnum]]` bug).
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.nonEnumShadows = !/valueOf/.test(props);
|
|
|
|
/**
|
|
* Detect if own properties are iterated after inherited properties (IE < 9).
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.ownLast = props[0] != 'x';
|
|
|
|
/**
|
|
* Detect if `Array#shift` and `Array#splice` augment array-like objects
|
|
* correctly.
|
|
*
|
|
* Firefox < 10, compatibility modes of IE 8, and IE < 9 have buggy Array
|
|
* `shift()` and `splice()` functions that fail to remove the last element,
|
|
* `value[0]`, of array-like objects even though the "length" property is
|
|
* set to `0`. The `shift()` method is buggy in compatibility modes of IE 8,
|
|
* while `splice()` is buggy regardless of mode in IE < 9.
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.spliceObjects = (splice.call(object, 0, 1), !object[0]);
|
|
|
|
/**
|
|
* Detect lack of support for accessing string characters by index.
|
|
*
|
|
* IE < 8 can't access characters by index. IE 8 can only access characters
|
|
* by index on string literals, not string objects.
|
|
*
|
|
* @memberOf _.support
|
|
* @type boolean
|
|
*/
|
|
support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx';
|
|
}(1, 0));
|
|
|
|
module.exports = support;
|
|
|
|
},{}],42:[function(_dereq_,module,exports){
|
|
/**
|
|
* This method returns the first argument provided to it.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @category Utility
|
|
* @param {*} value Any value.
|
|
* @returns {*} Returns `value`.
|
|
* @example
|
|
*
|
|
* var object = { 'user': 'fred' };
|
|
*
|
|
* _.identity(object) === object;
|
|
* // => true
|
|
*/
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
|
|
module.exports = identity;
|
|
|
|
},{}],43:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var keys = _dereq_('object-keys');
|
|
|
|
module.exports = function hasSymbols() {
|
|
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
|
|
if (typeof Symbol.iterator === 'symbol') { return true; }
|
|
|
|
var obj = {};
|
|
var sym = Symbol('test');
|
|
if (typeof sym === 'string') { return false; }
|
|
|
|
// temp disabled per https://github.com/ljharb/object.assign/issues/17
|
|
// if (sym instanceof Symbol) { return false; }
|
|
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
|
|
// if (!(Object(sym) instanceof Symbol)) { return false; }
|
|
|
|
var symVal = 42;
|
|
obj[sym] = symVal;
|
|
for (sym in obj) { return false; }
|
|
if (keys(obj).length !== 0) { return false; }
|
|
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
|
|
|
|
var syms = Object.getOwnPropertySymbols(obj);
|
|
if (syms.length !== 1 || syms[0] !== sym) { return false; }
|
|
|
|
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyDescriptor === 'function') {
|
|
var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
|
|
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
},{"object-keys":50}],44:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
// modified from https://github.com/es-shims/es6-shim
|
|
var keys = _dereq_('object-keys');
|
|
var bind = _dereq_('function-bind');
|
|
var canBeObject = function (obj) {
|
|
return typeof obj !== 'undefined' && obj !== null;
|
|
};
|
|
var hasSymbols = _dereq_('./hasSymbols')();
|
|
var toObject = Object;
|
|
var push = bind.call(Function.call, Array.prototype.push);
|
|
var propIsEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable);
|
|
|
|
module.exports = function assign(target, source1) {
|
|
if (!canBeObject(target)) { throw new TypeError('target must be an object'); }
|
|
var objTarget = toObject(target);
|
|
var s, source, i, props, syms, value, key;
|
|
for (s = 1; s < arguments.length; ++s) {
|
|
source = toObject(arguments[s]);
|
|
props = keys(source);
|
|
if (hasSymbols && Object.getOwnPropertySymbols) {
|
|
syms = Object.getOwnPropertySymbols(source);
|
|
for (i = 0; i < syms.length; ++i) {
|
|
key = syms[i];
|
|
if (propIsEnumerable(source, key)) {
|
|
push(props, key);
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < props.length; ++i) {
|
|
key = props[i];
|
|
value = source[key];
|
|
if (propIsEnumerable(source, key)) {
|
|
objTarget[key] = value;
|
|
}
|
|
}
|
|
}
|
|
return objTarget;
|
|
};
|
|
|
|
},{"./hasSymbols":43,"function-bind":49,"object-keys":50}],45:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var defineProperties = _dereq_('define-properties');
|
|
|
|
var implementation = _dereq_('./implementation');
|
|
var getPolyfill = _dereq_('./polyfill');
|
|
var shim = _dereq_('./shim');
|
|
|
|
defineProperties(implementation, {
|
|
implementation: implementation,
|
|
getPolyfill: getPolyfill,
|
|
shim: shim
|
|
});
|
|
|
|
module.exports = implementation;
|
|
|
|
},{"./implementation":44,"./polyfill":52,"./shim":53,"define-properties":46}],46:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var keys = _dereq_('object-keys');
|
|
var foreach = _dereq_('foreach');
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
var isFunction = function (fn) {
|
|
return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
|
|
};
|
|
|
|
var arePropertyDescriptorsSupported = function () {
|
|
var obj = {};
|
|
try {
|
|
Object.defineProperty(obj, 'x', { enumerable: false, value: obj });
|
|
/* eslint-disable no-unused-vars, no-restricted-syntax */
|
|
for (var _ in obj) { return false; }
|
|
/* eslint-enable no-unused-vars, no-restricted-syntax */
|
|
return obj.x === obj;
|
|
} catch (e) { /* this is IE 8. */
|
|
return false;
|
|
}
|
|
};
|
|
var supportsDescriptors = Object.defineProperty && arePropertyDescriptorsSupported();
|
|
|
|
var defineProperty = function (object, name, value, predicate) {
|
|
if (name in object && (!isFunction(predicate) || !predicate())) {
|
|
return;
|
|
}
|
|
if (supportsDescriptors) {
|
|
Object.defineProperty(object, name, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: value,
|
|
writable: true
|
|
});
|
|
} else {
|
|
object[name] = value;
|
|
}
|
|
};
|
|
|
|
var defineProperties = function (object, map) {
|
|
var predicates = arguments.length > 2 ? arguments[2] : {};
|
|
var props = keys(map);
|
|
if (hasSymbols) {
|
|
props = props.concat(Object.getOwnPropertySymbols(map));
|
|
}
|
|
foreach(props, function (name) {
|
|
defineProperty(object, name, map[name], predicates[name]);
|
|
});
|
|
};
|
|
|
|
defineProperties.supportsDescriptors = !!supportsDescriptors;
|
|
|
|
module.exports = defineProperties;
|
|
|
|
},{"foreach":47,"object-keys":50}],47:[function(_dereq_,module,exports){
|
|
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var toString = Object.prototype.toString;
|
|
|
|
module.exports = function forEach (obj, fn, ctx) {
|
|
if (toString.call(fn) !== '[object Function]') {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
var l = obj.length;
|
|
if (l === +l) {
|
|
for (var i = 0; i < l; i++) {
|
|
fn.call(ctx, obj[i], i, obj);
|
|
}
|
|
} else {
|
|
for (var k in obj) {
|
|
if (hasOwn.call(obj, k)) {
|
|
fn.call(ctx, obj[k], k, obj);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
},{}],48:[function(_dereq_,module,exports){
|
|
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
|
|
var slice = Array.prototype.slice;
|
|
var toStr = Object.prototype.toString;
|
|
var funcType = '[object Function]';
|
|
|
|
module.exports = function bind(that) {
|
|
var target = this;
|
|
if (typeof target !== 'function' || toStr.call(target) !== funcType) {
|
|
throw new TypeError(ERROR_MESSAGE + target);
|
|
}
|
|
var args = slice.call(arguments, 1);
|
|
|
|
var bound;
|
|
var binder = function () {
|
|
if (this instanceof bound) {
|
|
var result = target.apply(
|
|
this,
|
|
args.concat(slice.call(arguments))
|
|
);
|
|
if (Object(result) === result) {
|
|
return result;
|
|
}
|
|
return this;
|
|
} else {
|
|
return target.apply(
|
|
that,
|
|
args.concat(slice.call(arguments))
|
|
);
|
|
}
|
|
};
|
|
|
|
var boundLength = Math.max(0, target.length - args.length);
|
|
var boundArgs = [];
|
|
for (var i = 0; i < boundLength; i++) {
|
|
boundArgs.push('$' + i);
|
|
}
|
|
|
|
bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
|
|
|
|
if (target.prototype) {
|
|
var Empty = function Empty() {};
|
|
Empty.prototype = target.prototype;
|
|
bound.prototype = new Empty();
|
|
Empty.prototype = null;
|
|
}
|
|
|
|
return bound;
|
|
};
|
|
|
|
},{}],49:[function(_dereq_,module,exports){
|
|
var implementation = _dereq_('./implementation');
|
|
|
|
module.exports = Function.prototype.bind || implementation;
|
|
|
|
},{"./implementation":48}],50:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
// modified from https://github.com/es-shims/es5-shim
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var toStr = Object.prototype.toString;
|
|
var slice = Array.prototype.slice;
|
|
var isArgs = _dereq_('./isArguments');
|
|
var hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');
|
|
var hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype');
|
|
var dontEnums = [
|
|
'toString',
|
|
'toLocaleString',
|
|
'valueOf',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'constructor'
|
|
];
|
|
var equalsConstructorPrototype = function (o) {
|
|
var ctor = o.constructor;
|
|
return ctor && ctor.prototype === o;
|
|
};
|
|
var blacklistedKeys = {
|
|
$console: true,
|
|
$frame: true,
|
|
$frameElement: true,
|
|
$frames: true,
|
|
$parent: true,
|
|
$self: true,
|
|
$webkitIndexedDB: true,
|
|
$webkitStorageInfo: true,
|
|
$window: true
|
|
};
|
|
var hasAutomationEqualityBug = (function () {
|
|
/* global window */
|
|
if (typeof window === 'undefined') { return false; }
|
|
for (var k in window) {
|
|
try {
|
|
if (!blacklistedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
|
|
try {
|
|
equalsConstructorPrototype(window[k]);
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}());
|
|
var equalsConstructorPrototypeIfNotBuggy = function (o) {
|
|
/* global window */
|
|
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
|
|
return equalsConstructorPrototype(o);
|
|
}
|
|
try {
|
|
return equalsConstructorPrototype(o);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var keysShim = function keys(object) {
|
|
var isObject = object !== null && typeof object === 'object';
|
|
var isFunction = toStr.call(object) === '[object Function]';
|
|
var isArguments = isArgs(object);
|
|
var isString = isObject && toStr.call(object) === '[object String]';
|
|
var theKeys = [];
|
|
|
|
if (!isObject && !isFunction && !isArguments) {
|
|
throw new TypeError('Object.keys called on a non-object');
|
|
}
|
|
|
|
var skipProto = hasProtoEnumBug && isFunction;
|
|
if (isString && object.length > 0 && !has.call(object, 0)) {
|
|
for (var i = 0; i < object.length; ++i) {
|
|
theKeys.push(String(i));
|
|
}
|
|
}
|
|
|
|
if (isArguments && object.length > 0) {
|
|
for (var j = 0; j < object.length; ++j) {
|
|
theKeys.push(String(j));
|
|
}
|
|
} else {
|
|
for (var name in object) {
|
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
|
|
theKeys.push(String(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasDontEnumBug) {
|
|
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
|
|
|
|
for (var k = 0; k < dontEnums.length; ++k) {
|
|
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
|
|
theKeys.push(dontEnums[k]);
|
|
}
|
|
}
|
|
}
|
|
return theKeys;
|
|
};
|
|
|
|
keysShim.shim = function shimObjectKeys() {
|
|
if (Object.keys) {
|
|
var keysWorksWithArguments = (function () {
|
|
// Safari 5.0 bug
|
|
return (Object.keys(arguments) || '').length === 2;
|
|
}(1, 2));
|
|
if (!keysWorksWithArguments) {
|
|
var originalKeys = Object.keys;
|
|
Object.keys = function keys(object) {
|
|
if (isArgs(object)) {
|
|
return originalKeys(slice.call(object));
|
|
} else {
|
|
return originalKeys(object);
|
|
}
|
|
};
|
|
}
|
|
} else {
|
|
Object.keys = keysShim;
|
|
}
|
|
return Object.keys || keysShim;
|
|
};
|
|
|
|
module.exports = keysShim;
|
|
|
|
},{"./isArguments":51}],51:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
module.exports = function isArguments(value) {
|
|
var str = toStr.call(value);
|
|
var isArgs = str === '[object Arguments]';
|
|
if (!isArgs) {
|
|
isArgs = str !== '[object Array]' &&
|
|
value !== null &&
|
|
typeof value === 'object' &&
|
|
typeof value.length === 'number' &&
|
|
value.length >= 0 &&
|
|
toStr.call(value.callee) === '[object Function]';
|
|
}
|
|
return isArgs;
|
|
};
|
|
|
|
},{}],52:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var implementation = _dereq_('./implementation');
|
|
|
|
var lacksProperEnumerationOrder = function () {
|
|
if (!Object.assign) {
|
|
return false;
|
|
}
|
|
// v8, specifically in node 4.x, has a bug with incorrect property enumeration order
|
|
// note: this does not detect the bug unless there's 20 characters
|
|
var str = 'abcdefghijklmnopqrst';
|
|
var letters = str.split('');
|
|
var map = {};
|
|
for (var i = 0; i < letters.length; ++i) {
|
|
map[letters[i]] = letters[i];
|
|
}
|
|
var obj = Object.assign({}, map);
|
|
var actual = '';
|
|
for (var k in obj) {
|
|
actual += k;
|
|
}
|
|
return str !== actual;
|
|
};
|
|
|
|
var assignHasPendingExceptions = function () {
|
|
if (!Object.assign || !Object.preventExtensions) {
|
|
return false;
|
|
}
|
|
// Firefox 37 still has "pending exception" logic in its Object.assign implementation,
|
|
// which is 72% slower than our shim, and Firefox 40's native implementation.
|
|
var thrower = Object.preventExtensions({ 1: 2 });
|
|
try {
|
|
Object.assign(thrower, 'xy');
|
|
} catch (e) {
|
|
return thrower[1] === 'y';
|
|
}
|
|
};
|
|
|
|
module.exports = function getPolyfill() {
|
|
if (!Object.assign) {
|
|
return implementation;
|
|
}
|
|
if (lacksProperEnumerationOrder()) {
|
|
return implementation;
|
|
}
|
|
if (assignHasPendingExceptions()) {
|
|
return implementation;
|
|
}
|
|
return Object.assign;
|
|
};
|
|
|
|
},{"./implementation":44}],53:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
var define = _dereq_('define-properties');
|
|
var getPolyfill = _dereq_('./polyfill');
|
|
|
|
module.exports = function shimAssign() {
|
|
var polyfill = getPolyfill();
|
|
define(
|
|
Object,
|
|
{ assign: polyfill },
|
|
{ assign: function () { return Object.assign !== polyfill; } }
|
|
);
|
|
return polyfill;
|
|
};
|
|
|
|
},{"./polyfill":52,"define-properties":46}],54:[function(_dereq_,module,exports){
|
|
module.exports = SafeParseTuple
|
|
|
|
function SafeParseTuple(obj, reviver) {
|
|
var json
|
|
var error = null
|
|
|
|
try {
|
|
json = JSON.parse(obj, reviver)
|
|
} catch (err) {
|
|
error = err
|
|
}
|
|
|
|
return [error, json]
|
|
}
|
|
|
|
},{}],55:[function(_dereq_,module,exports){
|
|
function clean (s) {
|
|
return s.replace(/\n\r?\s*/g, '')
|
|
}
|
|
|
|
|
|
module.exports = function tsml (sa) {
|
|
var s = ''
|
|
, i = 0
|
|
|
|
for (; i < arguments.length; i++)
|
|
s += clean(sa[i]) + (arguments[i + 1] || '')
|
|
|
|
return s
|
|
}
|
|
},{}],56:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var window = _dereq_("global/window")
|
|
var once = _dereq_("once")
|
|
var isFunction = _dereq_("is-function")
|
|
var parseHeaders = _dereq_("parse-headers")
|
|
var xtend = _dereq_("xtend")
|
|
|
|
module.exports = createXHR
|
|
createXHR.XMLHttpRequest = window.XMLHttpRequest || noop
|
|
createXHR.XDomainRequest = "withCredentials" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window.XDomainRequest
|
|
|
|
forEachArray(["get", "put", "post", "patch", "head", "delete"], function(method) {
|
|
createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
|
|
options = initParams(uri, options, callback)
|
|
options.method = method.toUpperCase()
|
|
return _createXHR(options)
|
|
}
|
|
})
|
|
|
|
function forEachArray(array, iterator) {
|
|
for (var i = 0; i < array.length; i++) {
|
|
iterator(array[i])
|
|
}
|
|
}
|
|
|
|
function isEmpty(obj){
|
|
for(var i in obj){
|
|
if(obj.hasOwnProperty(i)) return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
function initParams(uri, options, callback) {
|
|
var params = uri
|
|
|
|
if (isFunction(options)) {
|
|
callback = options
|
|
if (typeof uri === "string") {
|
|
params = {uri:uri}
|
|
}
|
|
} else {
|
|
params = xtend(options, {uri: uri})
|
|
}
|
|
|
|
params.callback = callback
|
|
return params
|
|
}
|
|
|
|
function createXHR(uri, options, callback) {
|
|
options = initParams(uri, options, callback)
|
|
return _createXHR(options)
|
|
}
|
|
|
|
function _createXHR(options) {
|
|
var callback = options.callback
|
|
if(typeof callback === "undefined"){
|
|
throw new Error("callback argument missing")
|
|
}
|
|
callback = once(callback)
|
|
|
|
function readystatechange() {
|
|
if (xhr.readyState === 4) {
|
|
loadFunc()
|
|
}
|
|
}
|
|
|
|
function getBody() {
|
|
// Chrome with requestType=blob throws errors arround when even testing access to responseText
|
|
var body = undefined
|
|
|
|
if (xhr.response) {
|
|
body = xhr.response
|
|
} else if (xhr.responseType === "text" || !xhr.responseType) {
|
|
body = xhr.responseText || xhr.responseXML
|
|
}
|
|
|
|
if (isJson) {
|
|
try {
|
|
body = JSON.parse(body)
|
|
} catch (e) {}
|
|
}
|
|
|
|
return body
|
|
}
|
|
|
|
var failureResponse = {
|
|
body: undefined,
|
|
headers: {},
|
|
statusCode: 0,
|
|
method: method,
|
|
url: uri,
|
|
rawRequest: xhr
|
|
}
|
|
|
|
function errorFunc(evt) {
|
|
clearTimeout(timeoutTimer)
|
|
if(!(evt instanceof Error)){
|
|
evt = new Error("" + (evt || "Unknown XMLHttpRequest Error") )
|
|
}
|
|
evt.statusCode = 0
|
|
callback(evt, failureResponse)
|
|
}
|
|
|
|
// will load the data & process the response in a special response object
|
|
function loadFunc() {
|
|
if (aborted) return
|
|
var status
|
|
clearTimeout(timeoutTimer)
|
|
if(options.useXDR && xhr.status===undefined) {
|
|
//IE8 CORS GET successful response doesn't have a status field, but body is fine
|
|
status = 200
|
|
} else {
|
|
status = (xhr.status === 1223 ? 204 : xhr.status)
|
|
}
|
|
var response = failureResponse
|
|
var err = null
|
|
|
|
if (status !== 0){
|
|
response = {
|
|
body: getBody(),
|
|
statusCode: status,
|
|
method: method,
|
|
headers: {},
|
|
url: uri,
|
|
rawRequest: xhr
|
|
}
|
|
if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE
|
|
response.headers = parseHeaders(xhr.getAllResponseHeaders())
|
|
}
|
|
} else {
|
|
err = new Error("Internal XMLHttpRequest Error")
|
|
}
|
|
callback(err, response, response.body)
|
|
|
|
}
|
|
|
|
var xhr = options.xhr || null
|
|
|
|
if (!xhr) {
|
|
if (options.cors || options.useXDR) {
|
|
xhr = new createXHR.XDomainRequest()
|
|
}else{
|
|
xhr = new createXHR.XMLHttpRequest()
|
|
}
|
|
}
|
|
|
|
var key
|
|
var aborted
|
|
var uri = xhr.url = options.uri || options.url
|
|
var method = xhr.method = options.method || "GET"
|
|
var body = options.body || options.data || null
|
|
var headers = xhr.headers = options.headers || {}
|
|
var sync = !!options.sync
|
|
var isJson = false
|
|
var timeoutTimer
|
|
|
|
if ("json" in options) {
|
|
isJson = true
|
|
headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json") //Don't override existing accept header declared by user
|
|
if (method !== "GET" && method !== "HEAD") {
|
|
headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json") //Don't override existing accept header declared by user
|
|
body = JSON.stringify(options.json)
|
|
}
|
|
}
|
|
|
|
xhr.onreadystatechange = readystatechange
|
|
xhr.onload = loadFunc
|
|
xhr.onerror = errorFunc
|
|
// IE9 must have onprogress be set to a unique function.
|
|
xhr.onprogress = function () {
|
|
// IE must die
|
|
}
|
|
xhr.ontimeout = errorFunc
|
|
xhr.open(method, uri, !sync, options.username, options.password)
|
|
//has to be after open
|
|
if(!sync) {
|
|
xhr.withCredentials = !!options.withCredentials
|
|
}
|
|
// Cannot set timeout with sync request
|
|
// not setting timeout on the xhr object, because of old webkits etc. not handling that correctly
|
|
// both npm's request and jquery 1.x use this kind of timeout, so this is being consistent
|
|
if (!sync && options.timeout > 0 ) {
|
|
timeoutTimer = setTimeout(function(){
|
|
aborted=true//IE9 may still call readystatechange
|
|
xhr.abort("timeout")
|
|
var e = new Error("XMLHttpRequest timeout")
|
|
e.code = "ETIMEDOUT"
|
|
errorFunc(e)
|
|
}, options.timeout )
|
|
}
|
|
|
|
if (xhr.setRequestHeader) {
|
|
for(key in headers){
|
|
if(headers.hasOwnProperty(key)){
|
|
xhr.setRequestHeader(key, headers[key])
|
|
}
|
|
}
|
|
} else if (options.headers && !isEmpty(options.headers)) {
|
|
throw new Error("Headers cannot be set on an XDomainRequest object")
|
|
}
|
|
|
|
if ("responseType" in options) {
|
|
xhr.responseType = options.responseType
|
|
}
|
|
|
|
if ("beforeSend" in options &&
|
|
typeof options.beforeSend === "function"
|
|
) {
|
|
options.beforeSend(xhr)
|
|
}
|
|
|
|
xhr.send(body)
|
|
|
|
return xhr
|
|
|
|
|
|
}
|
|
|
|
function noop() {}
|
|
|
|
},{"global/window":2,"is-function":57,"once":58,"parse-headers":61,"xtend":62}],57:[function(_dereq_,module,exports){
|
|
module.exports = isFunction
|
|
|
|
var toString = Object.prototype.toString
|
|
|
|
function isFunction (fn) {
|
|
var string = toString.call(fn)
|
|
return string === '[object Function]' ||
|
|
(typeof fn === 'function' && string !== '[object RegExp]') ||
|
|
(typeof window !== 'undefined' &&
|
|
// IE8 and below
|
|
(fn === window.setTimeout ||
|
|
fn === window.alert ||
|
|
fn === window.confirm ||
|
|
fn === window.prompt))
|
|
};
|
|
|
|
},{}],58:[function(_dereq_,module,exports){
|
|
module.exports = once
|
|
|
|
once.proto = once(function () {
|
|
Object.defineProperty(Function.prototype, 'once', {
|
|
value: function () {
|
|
return once(this)
|
|
},
|
|
configurable: true
|
|
})
|
|
})
|
|
|
|
function once (fn) {
|
|
var called = false
|
|
return function () {
|
|
if (called) return
|
|
called = true
|
|
return fn.apply(this, arguments)
|
|
}
|
|
}
|
|
|
|
},{}],59:[function(_dereq_,module,exports){
|
|
var isFunction = _dereq_('is-function')
|
|
|
|
module.exports = forEach
|
|
|
|
var toString = Object.prototype.toString
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty
|
|
|
|
function forEach(list, iterator, context) {
|
|
if (!isFunction(iterator)) {
|
|
throw new TypeError('iterator must be a function')
|
|
}
|
|
|
|
if (arguments.length < 3) {
|
|
context = this
|
|
}
|
|
|
|
if (toString.call(list) === '[object Array]')
|
|
forEachArray(list, iterator, context)
|
|
else if (typeof list === 'string')
|
|
forEachString(list, iterator, context)
|
|
else
|
|
forEachObject(list, iterator, context)
|
|
}
|
|
|
|
function forEachArray(array, iterator, context) {
|
|
for (var i = 0, len = array.length; i < len; i++) {
|
|
if (hasOwnProperty.call(array, i)) {
|
|
iterator.call(context, array[i], i, array)
|
|
}
|
|
}
|
|
}
|
|
|
|
function forEachString(string, iterator, context) {
|
|
for (var i = 0, len = string.length; i < len; i++) {
|
|
// no such thing as a sparse string.
|
|
iterator.call(context, string.charAt(i), i, string)
|
|
}
|
|
}
|
|
|
|
function forEachObject(object, iterator, context) {
|
|
for (var k in object) {
|
|
if (hasOwnProperty.call(object, k)) {
|
|
iterator.call(context, object[k], k, object)
|
|
}
|
|
}
|
|
}
|
|
|
|
},{"is-function":57}],60:[function(_dereq_,module,exports){
|
|
|
|
exports = module.exports = trim;
|
|
|
|
function trim(str){
|
|
return str.replace(/^\s*|\s*$/g, '');
|
|
}
|
|
|
|
exports.left = function(str){
|
|
return str.replace(/^\s*/, '');
|
|
};
|
|
|
|
exports.right = function(str){
|
|
return str.replace(/\s*$/, '');
|
|
};
|
|
|
|
},{}],61:[function(_dereq_,module,exports){
|
|
var trim = _dereq_('trim')
|
|
, forEach = _dereq_('for-each')
|
|
, isArray = function(arg) {
|
|
return Object.prototype.toString.call(arg) === '[object Array]';
|
|
}
|
|
|
|
module.exports = function (headers) {
|
|
if (!headers)
|
|
return {}
|
|
|
|
var result = {}
|
|
|
|
forEach(
|
|
trim(headers).split('\n')
|
|
, function (row) {
|
|
var index = row.indexOf(':')
|
|
, key = trim(row.slice(0, index)).toLowerCase()
|
|
, value = trim(row.slice(index + 1))
|
|
|
|
if (typeof(result[key]) === 'undefined') {
|
|
result[key] = value
|
|
} else if (isArray(result[key])) {
|
|
result[key].push(value)
|
|
} else {
|
|
result[key] = [ result[key], value ]
|
|
}
|
|
}
|
|
)
|
|
|
|
return result
|
|
}
|
|
},{"for-each":59,"trim":60}],62:[function(_dereq_,module,exports){
|
|
module.exports = extend
|
|
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
function extend() {
|
|
var target = {}
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var source = arguments[i]
|
|
|
|
for (var key in source) {
|
|
if (hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key]
|
|
}
|
|
}
|
|
}
|
|
|
|
return target
|
|
}
|
|
|
|
},{}],63:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file big-play-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _buttonJs = _dereq_('./button.js');
|
|
|
|
var _buttonJs2 = _interopRequireDefault(_buttonJs);
|
|
|
|
var _componentJs = _dereq_('./component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Initial play button. Shows before the video has played. The hiding of the
|
|
* big play button is done via CSS and player states.
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends Button
|
|
* @class BigPlayButton
|
|
*/
|
|
|
|
var BigPlayButton = (function (_Button) {
|
|
_inherits(BigPlayButton, _Button);
|
|
|
|
function BigPlayButton(player, options) {
|
|
_classCallCheck(this, BigPlayButton);
|
|
|
|
_Button.call(this, player, options);
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
BigPlayButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-big-play-button';
|
|
};
|
|
|
|
/**
|
|
* Handles click for play
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
BigPlayButton.prototype.handleClick = function handleClick() {
|
|
this.player_.play();
|
|
};
|
|
|
|
return BigPlayButton;
|
|
})(_buttonJs2['default']);
|
|
|
|
BigPlayButton.prototype.controlText_ = 'Play Video';
|
|
|
|
_componentJs2['default'].registerComponent('BigPlayButton', BigPlayButton);
|
|
exports['default'] = BigPlayButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./button.js":64,"./component.js":67}],64:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _clickableComponentJs = _dereq_('./clickable-component.js');
|
|
|
|
var _clickableComponentJs2 = _interopRequireDefault(_clickableComponentJs);
|
|
|
|
var _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsLogJs = _dereq_('./utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/**
|
|
* Base class for all buttons
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends ClickableComponent
|
|
* @class Button
|
|
*/
|
|
|
|
var Button = (function (_ClickableComponent) {
|
|
_inherits(Button, _ClickableComponent);
|
|
|
|
function Button(player, options) {
|
|
_classCallCheck(this, Button);
|
|
|
|
_ClickableComponent.call(this, player, options);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @param {String=} type Element's node type. e.g. 'div'
|
|
* @param {Object=} props An object of properties that should be set on the element
|
|
* @param {Object=} attributes An object of attributes that should be set on the element
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Button.prototype.createEl = function createEl() {
|
|
var tag = arguments.length <= 0 || arguments[0] === undefined ? 'button' : arguments[0];
|
|
var props = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
var attributes = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
|
|
|
props = _objectAssign2['default']({
|
|
className: this.buildCSSClass()
|
|
}, props);
|
|
|
|
if (tag !== 'button') {
|
|
_utilsLogJs2['default'].warn('Creating a Button with an HTML element of ' + tag + ' is deprecated; use ClickableComponent instead.');
|
|
|
|
// Add properties for clickable element which is not a native HTML button
|
|
props = _objectAssign2['default']({
|
|
tabIndex: 0
|
|
}, props);
|
|
|
|
// Add ARIA attributes for clickable element which is not a native HTML button
|
|
attributes = _objectAssign2['default']({
|
|
role: 'button'
|
|
}, attributes);
|
|
}
|
|
|
|
// Add attributes for button element
|
|
attributes = _objectAssign2['default']({
|
|
type: 'button', // Necessary since the default button type is "submit"
|
|
'aria-live': 'polite' // let the screen reader user know that the text of the button may change
|
|
}, attributes);
|
|
|
|
var el = _component2['default'].prototype.createEl.call(this, tag, props, attributes);
|
|
|
|
this.createControlTextEl(el);
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Adds a child component inside this button
|
|
*
|
|
* @param {String|Component} child The class name or instance of a child to add
|
|
* @param {Object=} options Options, including options to be passed to children of the child.
|
|
* @return {Component} The child component (created by this process if a string was used)
|
|
* @deprecated
|
|
* @method addChild
|
|
*/
|
|
|
|
Button.prototype.addChild = function addChild(child) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
var className = this.constructor.name;
|
|
_utilsLogJs2['default'].warn('Adding an actionable (user controllable) child to a Button (' + className + ') is not supported; use a ClickableComponent instead.');
|
|
|
|
// Avoid the error message generated by ClickableComponent's addChild method
|
|
return _component2['default'].prototype.addChild.call(this, child, options);
|
|
};
|
|
|
|
/**
|
|
* Handle KeyPress (document level) - Extend with specific functionality for button
|
|
*
|
|
* @method handleKeyPress
|
|
*/
|
|
|
|
Button.prototype.handleKeyPress = function handleKeyPress(event) {
|
|
// Ignore Space (32) or Enter (13) key operation, which is handled by the browser for a button.
|
|
if (event.which === 32 || event.which === 13) {} else {
|
|
_ClickableComponent.prototype.handleKeyPress.call(this, event); // Pass keypress handling up for unsupported keys
|
|
}
|
|
};
|
|
|
|
return Button;
|
|
})(_clickableComponentJs2['default']);
|
|
|
|
_component2['default'].registerComponent('Button', Button);
|
|
exports['default'] = Button;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./clickable-component.js":65,"./component":67,"./utils/events.js":144,"./utils/fn.js":145,"./utils/log.js":148,"global/document":1,"object.assign":45}],65:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsDomJs = _dereq_('./utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsLogJs = _dereq_('./utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/**
|
|
* Clickable Component which is clickable or keyboard actionable, but is not a native HTML button
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends Component
|
|
* @class ClickableComponent
|
|
*/
|
|
|
|
var ClickableComponent = (function (_Component) {
|
|
_inherits(ClickableComponent, _Component);
|
|
|
|
function ClickableComponent(player, options) {
|
|
_classCallCheck(this, ClickableComponent);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
this.emitTapEvents();
|
|
|
|
this.on('tap', this.handleClick);
|
|
this.on('click', this.handleClick);
|
|
this.on('focus', this.handleFocus);
|
|
this.on('blur', this.handleBlur);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @param {String=} type Element's node type. e.g. 'div'
|
|
* @param {Object=} props An object of properties that should be set on the element
|
|
* @param {Object=} attributes An object of attributes that should be set on the element
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
ClickableComponent.prototype.createEl = function createEl() {
|
|
var tag = arguments.length <= 0 || arguments[0] === undefined ? 'div' : arguments[0];
|
|
var props = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
var attributes = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
|
|
|
props = _objectAssign2['default']({
|
|
className: this.buildCSSClass(),
|
|
tabIndex: 0
|
|
}, props);
|
|
|
|
if (tag === 'button') {
|
|
_utilsLogJs2['default'].error('Creating a ClickableComponent with an HTML element of ' + tag + ' is not supported; use a Button instead.');
|
|
}
|
|
|
|
// Add ARIA attributes for clickable element which is not a native HTML button
|
|
attributes = _objectAssign2['default']({
|
|
role: 'button',
|
|
'aria-live': 'polite' // let the screen reader user know that the text of the element may change
|
|
}, attributes);
|
|
|
|
var el = _Component.prototype.createEl.call(this, tag, props, attributes);
|
|
|
|
this.createControlTextEl(el);
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* create control text
|
|
*
|
|
* @param {Element} el Parent element for the control text
|
|
* @return {Element}
|
|
* @method controlText
|
|
*/
|
|
|
|
ClickableComponent.prototype.createControlTextEl = function createControlTextEl(el) {
|
|
this.controlTextEl_ = Dom.createEl('span', {
|
|
className: 'vjs-control-text'
|
|
});
|
|
|
|
if (el) {
|
|
el.appendChild(this.controlTextEl_);
|
|
}
|
|
|
|
this.controlText(this.controlText_);
|
|
|
|
return this.controlTextEl_;
|
|
};
|
|
|
|
/**
|
|
* Controls text - both request and localize
|
|
*
|
|
* @param {String} text Text for element
|
|
* @return {String}
|
|
* @method controlText
|
|
*/
|
|
|
|
ClickableComponent.prototype.controlText = function controlText(text) {
|
|
if (!text) return this.controlText_ || 'Need Text';
|
|
|
|
this.controlText_ = text;
|
|
this.controlTextEl_.innerHTML = this.localize(this.controlText_);
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Allows sub components to stack CSS class names
|
|
*
|
|
* @return {String}
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
ClickableComponent.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-control vjs-button ' + _Component.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Adds a child component inside this clickable-component
|
|
*
|
|
* @param {String|Component} child The class name or instance of a child to add
|
|
* @param {Object=} options Options, including options to be passed to children of the child.
|
|
* @return {Component} The child component (created by this process if a string was used)
|
|
* @method addChild
|
|
*/
|
|
|
|
ClickableComponent.prototype.addChild = function addChild(child) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
// TODO: Fix adding an actionable child to a ClickableComponent; currently
|
|
// it will cause issues with assistive technology (e.g. screen readers)
|
|
// which support ARIA, since an element with role="button" cannot have
|
|
// actionable child elements.
|
|
|
|
//let className = this.constructor.name;
|
|
//log.warn(`Adding a child to a ClickableComponent (${className}) can cause issues with assistive technology which supports ARIA, since an element with role="button" cannot have actionable child elements.`);
|
|
|
|
return _Component.prototype.addChild.call(this, child, options);
|
|
};
|
|
|
|
/**
|
|
* Enable the component element
|
|
*
|
|
* @return {Component}
|
|
* @method enable
|
|
*/
|
|
|
|
ClickableComponent.prototype.enable = function enable() {
|
|
this.removeClass('vjs-disabled');
|
|
this.el_.setAttribute('aria-disabled', 'false');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Disable the component element
|
|
*
|
|
* @return {Component}
|
|
* @method disable
|
|
*/
|
|
|
|
ClickableComponent.prototype.disable = function disable() {
|
|
this.addClass('vjs-disabled');
|
|
this.el_.setAttribute('aria-disabled', 'true');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Handle Click - Override with specific functionality for component
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
ClickableComponent.prototype.handleClick = function handleClick() {};
|
|
|
|
/**
|
|
* Handle Focus - Add keyboard functionality to element
|
|
*
|
|
* @method handleFocus
|
|
*/
|
|
|
|
ClickableComponent.prototype.handleFocus = function handleFocus() {
|
|
Events.on(_globalDocument2['default'], 'keydown', Fn.bind(this, this.handleKeyPress));
|
|
};
|
|
|
|
/**
|
|
* Handle KeyPress (document level) - Trigger click when Space or Enter key is pressed
|
|
*
|
|
* @method handleKeyPress
|
|
*/
|
|
|
|
ClickableComponent.prototype.handleKeyPress = function handleKeyPress(event) {
|
|
// Support Space (32) or Enter (13) key operation to fire a click event
|
|
if (event.which === 32 || event.which === 13) {
|
|
event.preventDefault();
|
|
this.handleClick(event);
|
|
} else if (_Component.prototype.handleKeyPress) {
|
|
_Component.prototype.handleKeyPress.call(this, event); // Pass keypress handling up for unsupported keys
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle Blur - Remove keyboard triggers
|
|
*
|
|
* @method handleBlur
|
|
*/
|
|
|
|
ClickableComponent.prototype.handleBlur = function handleBlur() {
|
|
Events.off(_globalDocument2['default'], 'keydown', Fn.bind(this, this.handleKeyPress));
|
|
};
|
|
|
|
return ClickableComponent;
|
|
})(_component2['default']);
|
|
|
|
_component2['default'].registerComponent('ClickableComponent', ClickableComponent);
|
|
exports['default'] = ClickableComponent;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./component":67,"./utils/dom.js":143,"./utils/events.js":144,"./utils/fn.js":145,"./utils/log.js":148,"global/document":1,"object.assign":45}],66:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _button = _dereq_('./button');
|
|
|
|
var _button2 = _interopRequireDefault(_button);
|
|
|
|
var _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
/**
|
|
* The `CloseButton` component is a button which fires a "close" event
|
|
* when it is activated.
|
|
*
|
|
* @extends Button
|
|
* @class CloseButton
|
|
*/
|
|
|
|
var CloseButton = (function (_Button) {
|
|
_inherits(CloseButton, _Button);
|
|
|
|
function CloseButton(player, options) {
|
|
_classCallCheck(this, CloseButton);
|
|
|
|
_Button.call(this, player, options);
|
|
this.controlText(options && options.controlText || this.localize('Close'));
|
|
}
|
|
|
|
CloseButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-close-button ' + _Button.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
CloseButton.prototype.handleClick = function handleClick() {
|
|
this.trigger({ type: 'close', bubbles: false });
|
|
};
|
|
|
|
return CloseButton;
|
|
})(_button2['default']);
|
|
|
|
_component2['default'].registerComponent('CloseButton', CloseButton);
|
|
exports['default'] = CloseButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./button":64,"./component":67}],67:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file component.js
|
|
*
|
|
* Player Component - Base class for all UI objects
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _utilsDomJs = _dereq_('./utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsGuidJs = _dereq_('./utils/guid.js');
|
|
|
|
var Guid = _interopRequireWildcard(_utilsGuidJs);
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _utilsLogJs = _dereq_('./utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('./utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var _utilsMergeOptionsJs = _dereq_('./utils/merge-options.js');
|
|
|
|
var _utilsMergeOptionsJs2 = _interopRequireDefault(_utilsMergeOptionsJs);
|
|
|
|
/**
|
|
* Base UI Component class
|
|
* Components are embeddable UI objects that are represented by both a
|
|
* javascript object and an element in the DOM. They can be children of other
|
|
* components, and can have many children themselves.
|
|
* ```js
|
|
* // adding a button to the player
|
|
* var button = player.addChild('button');
|
|
* button.el(); // -> button element
|
|
* ```
|
|
* ```html
|
|
* <div class="video-js">
|
|
* <div class="vjs-button">Button</div>
|
|
* </div>
|
|
* ```
|
|
* Components are also event targets.
|
|
* ```js
|
|
* button.on('click', function(){
|
|
* console.log('Button Clicked!');
|
|
* });
|
|
* button.trigger('customevent');
|
|
* ```
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @class Component
|
|
*/
|
|
|
|
var Component = (function () {
|
|
function Component(player, options, ready) {
|
|
_classCallCheck(this, Component);
|
|
|
|
// The component might be the player itself and we can't pass `this` to super
|
|
if (!player && this.play) {
|
|
this.player_ = player = this; // eslint-disable-line
|
|
} else {
|
|
this.player_ = player;
|
|
}
|
|
|
|
// Make a copy of prototype.options_ to protect against overriding defaults
|
|
this.options_ = _utilsMergeOptionsJs2['default']({}, this.options_);
|
|
|
|
// Updated options with supplied options
|
|
options = this.options_ = _utilsMergeOptionsJs2['default'](this.options_, options);
|
|
|
|
// Get ID from options or options element if one is supplied
|
|
this.id_ = options.id || options.el && options.el.id;
|
|
|
|
// If there was no ID from the options, generate one
|
|
if (!this.id_) {
|
|
// Don't require the player ID function in the case of mock players
|
|
var id = player && player.id && player.id() || 'no_player';
|
|
|
|
this.id_ = id + '_component_' + Guid.newGUID();
|
|
}
|
|
|
|
this.name_ = options.name || null;
|
|
|
|
// Create element if one wasn't provided in options
|
|
if (options.el) {
|
|
this.el_ = options.el;
|
|
} else if (options.createEl !== false) {
|
|
this.el_ = this.createEl();
|
|
}
|
|
|
|
this.children_ = [];
|
|
this.childIndex_ = {};
|
|
this.childNameIndex_ = {};
|
|
|
|
// Add any child components in options
|
|
if (options.initChildren !== false) {
|
|
this.initChildren();
|
|
}
|
|
|
|
this.ready(ready);
|
|
// Don't want to trigger ready here or it will before init is actually
|
|
// finished for all children that run this constructor
|
|
|
|
if (options.reportTouchActivity !== false) {
|
|
this.enableTouchActivity();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dispose of the component and all child components
|
|
*
|
|
* @method dispose
|
|
*/
|
|
|
|
Component.prototype.dispose = function dispose() {
|
|
this.trigger({ type: 'dispose', bubbles: false });
|
|
|
|
// Dispose all children.
|
|
if (this.children_) {
|
|
for (var i = this.children_.length - 1; i >= 0; i--) {
|
|
if (this.children_[i].dispose) {
|
|
this.children_[i].dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete child references
|
|
this.children_ = null;
|
|
this.childIndex_ = null;
|
|
this.childNameIndex_ = null;
|
|
|
|
// Remove all event listeners.
|
|
this.off();
|
|
|
|
// Remove element from DOM
|
|
if (this.el_.parentNode) {
|
|
this.el_.parentNode.removeChild(this.el_);
|
|
}
|
|
|
|
Dom.removeElData(this.el_);
|
|
this.el_ = null;
|
|
};
|
|
|
|
/**
|
|
* Return the component's player
|
|
*
|
|
* @return {Player}
|
|
* @method player
|
|
*/
|
|
|
|
Component.prototype.player = function player() {
|
|
return this.player_;
|
|
};
|
|
|
|
/**
|
|
* Deep merge of options objects
|
|
* Whenever a property is an object on both options objects
|
|
* the two properties will be merged using mergeOptions.
|
|
*
|
|
* ```js
|
|
* Parent.prototype.options_ = {
|
|
* optionSet: {
|
|
* 'childOne': { 'foo': 'bar', 'asdf': 'fdsa' },
|
|
* 'childTwo': {},
|
|
* 'childThree': {}
|
|
* }
|
|
* }
|
|
* newOptions = {
|
|
* optionSet: {
|
|
* 'childOne': { 'foo': 'baz', 'abc': '123' }
|
|
* 'childTwo': null,
|
|
* 'childFour': {}
|
|
* }
|
|
* }
|
|
*
|
|
* this.options(newOptions);
|
|
* ```
|
|
* RESULT
|
|
* ```js
|
|
* {
|
|
* optionSet: {
|
|
* 'childOne': { 'foo': 'baz', 'asdf': 'fdsa', 'abc': '123' },
|
|
* 'childTwo': null, // Disabled. Won't be initialized.
|
|
* 'childThree': {},
|
|
* 'childFour': {}
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* @param {Object} obj Object of new option values
|
|
* @return {Object} A NEW object of this.options_ and obj merged
|
|
* @method options
|
|
*/
|
|
|
|
Component.prototype.options = function options(obj) {
|
|
_utilsLogJs2['default'].warn('this.options() has been deprecated and will be moved to the constructor in 6.0');
|
|
|
|
if (!obj) {
|
|
return this.options_;
|
|
}
|
|
|
|
this.options_ = _utilsMergeOptionsJs2['default'](this.options_, obj);
|
|
return this.options_;
|
|
};
|
|
|
|
/**
|
|
* Get the component's DOM element
|
|
* ```js
|
|
* var domEl = myComponent.el();
|
|
* ```
|
|
*
|
|
* @return {Element}
|
|
* @method el
|
|
*/
|
|
|
|
Component.prototype.el = function el() {
|
|
return this.el_;
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @param {String=} tagName Element's node type. e.g. 'div'
|
|
* @param {Object=} properties An object of properties that should be set
|
|
* @param {Object=} attributes An object of attributes that should be set
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Component.prototype.createEl = function createEl(tagName, properties, attributes) {
|
|
return Dom.createEl(tagName, properties, attributes);
|
|
};
|
|
|
|
Component.prototype.localize = function localize(string) {
|
|
var code = this.player_.language && this.player_.language();
|
|
var languages = this.player_.languages && this.player_.languages();
|
|
|
|
if (!code || !languages) {
|
|
return string;
|
|
}
|
|
|
|
var language = languages[code];
|
|
|
|
if (language && language[string]) {
|
|
return language[string];
|
|
}
|
|
|
|
var primaryCode = code.split('-')[0];
|
|
var primaryLang = languages[primaryCode];
|
|
|
|
if (primaryLang && primaryLang[string]) {
|
|
return primaryLang[string];
|
|
}
|
|
|
|
return string;
|
|
};
|
|
|
|
/**
|
|
* Return the component's DOM element where children are inserted.
|
|
* Will either be the same as el() or a new element defined in createEl().
|
|
*
|
|
* @return {Element}
|
|
* @method contentEl
|
|
*/
|
|
|
|
Component.prototype.contentEl = function contentEl() {
|
|
return this.contentEl_ || this.el_;
|
|
};
|
|
|
|
/**
|
|
* Get the component's ID
|
|
* ```js
|
|
* var id = myComponent.id();
|
|
* ```
|
|
*
|
|
* @return {String}
|
|
* @method id
|
|
*/
|
|
|
|
Component.prototype.id = function id() {
|
|
return this.id_;
|
|
};
|
|
|
|
/**
|
|
* Get the component's name. The name is often used to reference the component.
|
|
* ```js
|
|
* var name = myComponent.name();
|
|
* ```
|
|
*
|
|
* @return {String}
|
|
* @method name
|
|
*/
|
|
|
|
Component.prototype.name = function name() {
|
|
return this.name_;
|
|
};
|
|
|
|
/**
|
|
* Get an array of all child components
|
|
* ```js
|
|
* var kids = myComponent.children();
|
|
* ```
|
|
*
|
|
* @return {Array} The children
|
|
* @method children
|
|
*/
|
|
|
|
Component.prototype.children = function children() {
|
|
return this.children_;
|
|
};
|
|
|
|
/**
|
|
* Returns a child component with the provided ID
|
|
*
|
|
* @return {Component}
|
|
* @method getChildById
|
|
*/
|
|
|
|
Component.prototype.getChildById = function getChildById(id) {
|
|
return this.childIndex_[id];
|
|
};
|
|
|
|
/**
|
|
* Returns a child component with the provided name
|
|
*
|
|
* @return {Component}
|
|
* @method getChild
|
|
*/
|
|
|
|
Component.prototype.getChild = function getChild(name) {
|
|
return this.childNameIndex_[name];
|
|
};
|
|
|
|
/**
|
|
* Adds a child component inside this component
|
|
* ```js
|
|
* myComponent.el();
|
|
* // -> <div class='my-component'></div>
|
|
* myComponent.children();
|
|
* // [empty array]
|
|
*
|
|
* var myButton = myComponent.addChild('MyButton');
|
|
* // -> <div class='my-component'><div class="my-button">myButton<div></div>
|
|
* // -> myButton === myComponent.children()[0];
|
|
* ```
|
|
* Pass in options for child constructors and options for children of the child
|
|
* ```js
|
|
* var myButton = myComponent.addChild('MyButton', {
|
|
* text: 'Press Me',
|
|
* buttonChildExample: {
|
|
* buttonChildOption: true
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* @param {String|Component} child The class name or instance of a child to add
|
|
* @param {Object=} options Options, including options to be passed to children of the child.
|
|
* @param {Number} index into our children array to attempt to add the child
|
|
* @return {Component} The child component (created by this process if a string was used)
|
|
* @method addChild
|
|
*/
|
|
|
|
Component.prototype.addChild = function addChild(child) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
var index = arguments.length <= 2 || arguments[2] === undefined ? this.children_.length : arguments[2];
|
|
|
|
var component = undefined;
|
|
var componentName = undefined;
|
|
|
|
// If child is a string, create nt with options
|
|
if (typeof child === 'string') {
|
|
componentName = child;
|
|
|
|
// Options can also be specified as a boolean, so convert to an empty object if false.
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
|
|
// Same as above, but true is deprecated so show a warning.
|
|
if (options === true) {
|
|
_utilsLogJs2['default'].warn('Initializing a child component with `true` is deprecated. Children should be defined in an array when possible, but if necessary use an object instead of `true`.');
|
|
options = {};
|
|
}
|
|
|
|
// If no componentClass in options, assume componentClass is the name lowercased
|
|
// (e.g. playButton)
|
|
var componentClassName = options.componentClass || _utilsToTitleCaseJs2['default'](componentName);
|
|
|
|
// Set name through options
|
|
options.name = componentName;
|
|
|
|
// Create a new object & element for this controls set
|
|
// If there's no .player_, this is a player
|
|
var ComponentClass = Component.getComponent(componentClassName);
|
|
|
|
if (!ComponentClass) {
|
|
throw new Error('Component ' + componentClassName + ' does not exist');
|
|
}
|
|
|
|
// data stored directly on the videojs object may be
|
|
// misidentified as a component to retain
|
|
// backwards-compatibility with 4.x. check to make sure the
|
|
// component class can be instantiated.
|
|
if (typeof ComponentClass !== 'function') {
|
|
return null;
|
|
}
|
|
|
|
component = new ComponentClass(this.player_ || this, options);
|
|
|
|
// child is a component instance
|
|
} else {
|
|
component = child;
|
|
}
|
|
|
|
this.children_.splice(index, 0, component);
|
|
|
|
if (typeof component.id === 'function') {
|
|
this.childIndex_[component.id()] = component;
|
|
}
|
|
|
|
// If a name wasn't used to create the component, check if we can use the
|
|
// name function of the component
|
|
componentName = componentName || component.name && component.name();
|
|
|
|
if (componentName) {
|
|
this.childNameIndex_[componentName] = component;
|
|
}
|
|
|
|
// Add the UI object's element to the container div (box)
|
|
// Having an element is not required
|
|
if (typeof component.el === 'function' && component.el()) {
|
|
var childNodes = this.contentEl().children;
|
|
var refNode = childNodes[index] || null;
|
|
this.contentEl().insertBefore(component.el(), refNode);
|
|
}
|
|
|
|
// Return so it can stored on parent object if desired.
|
|
return component;
|
|
};
|
|
|
|
/**
|
|
* Remove a child component from this component's list of children, and the
|
|
* child component's element from this component's element
|
|
*
|
|
* @param {Component} component Component to remove
|
|
* @method removeChild
|
|
*/
|
|
|
|
Component.prototype.removeChild = function removeChild(component) {
|
|
if (typeof component === 'string') {
|
|
component = this.getChild(component);
|
|
}
|
|
|
|
if (!component || !this.children_) {
|
|
return;
|
|
}
|
|
|
|
var childFound = false;
|
|
|
|
for (var i = this.children_.length - 1; i >= 0; i--) {
|
|
if (this.children_[i] === component) {
|
|
childFound = true;
|
|
this.children_.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!childFound) {
|
|
return;
|
|
}
|
|
|
|
this.childIndex_[component.id()] = null;
|
|
this.childNameIndex_[component.name()] = null;
|
|
|
|
var compEl = component.el();
|
|
|
|
if (compEl && compEl.parentNode === this.contentEl()) {
|
|
this.contentEl().removeChild(component.el());
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add and initialize default child components from options
|
|
* ```js
|
|
* // when an instance of MyComponent is created, all children in options
|
|
* // will be added to the instance by their name strings and options
|
|
* MyComponent.prototype.options_ = {
|
|
* children: [
|
|
* 'myChildComponent'
|
|
* ],
|
|
* myChildComponent: {
|
|
* myChildOption: true
|
|
* }
|
|
* };
|
|
*
|
|
* // Or when creating the component
|
|
* var myComp = new MyComponent(player, {
|
|
* children: [
|
|
* 'myChildComponent'
|
|
* ],
|
|
* myChildComponent: {
|
|
* myChildOption: true
|
|
* }
|
|
* });
|
|
* ```
|
|
* The children option can also be an array of
|
|
* child options objects (that also include a 'name' key).
|
|
* This can be used if you have two child components of the
|
|
* same type that need different options.
|
|
* ```js
|
|
* var myComp = new MyComponent(player, {
|
|
* children: [
|
|
* 'button',
|
|
* {
|
|
* name: 'button',
|
|
* someOtherOption: true
|
|
* },
|
|
* {
|
|
* name: 'button',
|
|
* someOtherOption: false
|
|
* }
|
|
* ]
|
|
* });
|
|
* ```
|
|
*
|
|
* @method initChildren
|
|
*/
|
|
|
|
Component.prototype.initChildren = function initChildren() {
|
|
var _this = this;
|
|
|
|
var children = this.options_.children;
|
|
|
|
if (children) {
|
|
(function () {
|
|
// `this` is `parent`
|
|
var parentOptions = _this.options_;
|
|
|
|
var handleAdd = function handleAdd(child) {
|
|
var name = child.name;
|
|
var opts = child.opts;
|
|
|
|
// Allow options for children to be set at the parent options
|
|
// e.g. videojs(id, { controlBar: false });
|
|
// instead of videojs(id, { children: { controlBar: false });
|
|
if (parentOptions[name] !== undefined) {
|
|
opts = parentOptions[name];
|
|
}
|
|
|
|
// Allow for disabling default components
|
|
// e.g. options['children']['posterImage'] = false
|
|
if (opts === false) {
|
|
return;
|
|
}
|
|
|
|
// Allow options to be passed as a simple boolean if no configuration
|
|
// is necessary.
|
|
if (opts === true) {
|
|
opts = {};
|
|
}
|
|
|
|
// We also want to pass the original player options to each component as well so they don't need to
|
|
// reach back into the player for options later.
|
|
opts.playerOptions = _this.options_.playerOptions;
|
|
|
|
// Create and add the child component.
|
|
// Add a direct reference to the child by name on the parent instance.
|
|
// If two of the same component are used, different names should be supplied
|
|
// for each
|
|
var newChild = _this.addChild(name, opts);
|
|
if (newChild) {
|
|
_this[name] = newChild;
|
|
}
|
|
};
|
|
|
|
// Allow for an array of children details to passed in the options
|
|
var workingChildren = undefined;
|
|
var Tech = Component.getComponent('Tech');
|
|
|
|
if (Array.isArray(children)) {
|
|
workingChildren = children;
|
|
} else {
|
|
workingChildren = Object.keys(children);
|
|
}
|
|
|
|
workingChildren
|
|
// children that are in this.options_ but also in workingChildren would
|
|
// give us extra children we do not want. So, we want to filter them out.
|
|
.concat(Object.keys(_this.options_).filter(function (child) {
|
|
return !workingChildren.some(function (wchild) {
|
|
if (typeof wchild === 'string') {
|
|
return child === wchild;
|
|
} else {
|
|
return child === wchild.name;
|
|
}
|
|
});
|
|
})).map(function (child) {
|
|
var name = undefined,
|
|
opts = undefined;
|
|
|
|
if (typeof child === 'string') {
|
|
name = child;
|
|
opts = children[name] || _this.options_[name] || {};
|
|
} else {
|
|
name = child.name;
|
|
opts = child;
|
|
}
|
|
|
|
return { name: name, opts: opts };
|
|
}).filter(function (child) {
|
|
// we have to make sure that child.name isn't in the techOrder since
|
|
// techs are registerd as Components but can't aren't compatible
|
|
// See https://github.com/videojs/video.js/issues/2772
|
|
var c = Component.getComponent(child.opts.componentClass || _utilsToTitleCaseJs2['default'](child.name));
|
|
return c && !Tech.isTech(c);
|
|
}).forEach(handleAdd);
|
|
})();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Allows sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
Component.prototype.buildCSSClass = function buildCSSClass() {
|
|
// Child classes can include a function that does:
|
|
// return 'CLASS NAME' + this._super();
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Add an event listener to this component's element
|
|
* ```js
|
|
* var myFunc = function(){
|
|
* var myComponent = this;
|
|
* // Do something when the event is fired
|
|
* };
|
|
*
|
|
* myComponent.on('eventType', myFunc);
|
|
* ```
|
|
* The context of myFunc will be myComponent unless previously bound.
|
|
* Alternatively, you can add a listener to another element or component.
|
|
* ```js
|
|
* myComponent.on(otherElement, 'eventName', myFunc);
|
|
* myComponent.on(otherComponent, 'eventName', myFunc);
|
|
* ```
|
|
* The benefit of using this over `VjsEvents.on(otherElement, 'eventName', myFunc)`
|
|
* and `otherComponent.on('eventName', myFunc)` is that this way the listeners
|
|
* will be automatically cleaned up when either component is disposed.
|
|
* It will also bind myComponent as the context of myFunc.
|
|
* **NOTE**: When using this on elements in the page other than window
|
|
* and document (both permanent), if you remove the element from the DOM
|
|
* you need to call `myComponent.trigger(el, 'dispose')` on it to clean up
|
|
* references to it and allow the browser to garbage collect it.
|
|
*
|
|
* @param {String|Component} first The event type or other component
|
|
* @param {Function|String} second The event handler or event type
|
|
* @param {Function} third The event handler
|
|
* @return {Component}
|
|
* @method on
|
|
*/
|
|
|
|
Component.prototype.on = function on(first, second, third) {
|
|
var _this2 = this;
|
|
|
|
if (typeof first === 'string' || Array.isArray(first)) {
|
|
Events.on(this.el_, first, Fn.bind(this, second));
|
|
|
|
// Targeting another component or element
|
|
} else {
|
|
(function () {
|
|
var target = first;
|
|
var type = second;
|
|
var fn = Fn.bind(_this2, third);
|
|
|
|
// When this component is disposed, remove the listener from the other component
|
|
var removeOnDispose = function removeOnDispose() {
|
|
return _this2.off(target, type, fn);
|
|
};
|
|
|
|
// Use the same function ID so we can remove it later it using the ID
|
|
// of the original listener
|
|
removeOnDispose.guid = fn.guid;
|
|
_this2.on('dispose', removeOnDispose);
|
|
|
|
// If the other component is disposed first we need to clean the reference
|
|
// to the other component in this component's removeOnDispose listener
|
|
// Otherwise we create a memory leak.
|
|
var cleanRemover = function cleanRemover() {
|
|
return _this2.off('dispose', removeOnDispose);
|
|
};
|
|
|
|
// Add the same function ID so we can easily remove it later
|
|
cleanRemover.guid = fn.guid;
|
|
|
|
// Check if this is a DOM node
|
|
if (first.nodeName) {
|
|
// Add the listener to the other element
|
|
Events.on(target, type, fn);
|
|
Events.on(target, 'dispose', cleanRemover);
|
|
|
|
// Should be a component
|
|
// Not using `instanceof Component` because it makes mock players difficult
|
|
} else if (typeof first.on === 'function') {
|
|
// Add the listener to the other component
|
|
target.on(type, fn);
|
|
target.on('dispose', cleanRemover);
|
|
}
|
|
})();
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove an event listener from this component's element
|
|
* ```js
|
|
* myComponent.off('eventType', myFunc);
|
|
* ```
|
|
* If myFunc is excluded, ALL listeners for the event type will be removed.
|
|
* If eventType is excluded, ALL listeners will be removed from the component.
|
|
* Alternatively you can use `off` to remove listeners that were added to other
|
|
* elements or components using `myComponent.on(otherComponent...`.
|
|
* In this case both the event type and listener function are REQUIRED.
|
|
* ```js
|
|
* myComponent.off(otherElement, 'eventType', myFunc);
|
|
* myComponent.off(otherComponent, 'eventType', myFunc);
|
|
* ```
|
|
*
|
|
* @param {String=|Component} first The event type or other component
|
|
* @param {Function=|String} second The listener function or event type
|
|
* @param {Function=} third The listener for other component
|
|
* @return {Component}
|
|
* @method off
|
|
*/
|
|
|
|
Component.prototype.off = function off(first, second, third) {
|
|
if (!first || typeof first === 'string' || Array.isArray(first)) {
|
|
Events.off(this.el_, first, second);
|
|
} else {
|
|
var target = first;
|
|
var type = second;
|
|
// Ensure there's at least a guid, even if the function hasn't been used
|
|
var fn = Fn.bind(this, third);
|
|
|
|
// Remove the dispose listener on this component,
|
|
// which was given the same guid as the event listener
|
|
this.off('dispose', fn);
|
|
|
|
if (first.nodeName) {
|
|
// Remove the listener
|
|
Events.off(target, type, fn);
|
|
// Remove the listener for cleaning the dispose listener
|
|
Events.off(target, 'dispose', fn);
|
|
} else {
|
|
target.off(type, fn);
|
|
target.off('dispose', fn);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add an event listener to be triggered only once and then removed
|
|
* ```js
|
|
* myComponent.one('eventName', myFunc);
|
|
* ```
|
|
* Alternatively you can add a listener to another element or component
|
|
* that will be triggered only once.
|
|
* ```js
|
|
* myComponent.one(otherElement, 'eventName', myFunc);
|
|
* myComponent.one(otherComponent, 'eventName', myFunc);
|
|
* ```
|
|
*
|
|
* @param {String|Component} first The event type or other component
|
|
* @param {Function|String} second The listener function or event type
|
|
* @param {Function=} third The listener function for other component
|
|
* @return {Component}
|
|
* @method one
|
|
*/
|
|
|
|
Component.prototype.one = function one(first, second, third) {
|
|
var _this3 = this,
|
|
_arguments = arguments;
|
|
|
|
if (typeof first === 'string' || Array.isArray(first)) {
|
|
Events.one(this.el_, first, Fn.bind(this, second));
|
|
} else {
|
|
(function () {
|
|
var target = first;
|
|
var type = second;
|
|
var fn = Fn.bind(_this3, third);
|
|
|
|
var newFunc = function newFunc() {
|
|
_this3.off(target, type, newFunc);
|
|
fn.apply(null, _arguments);
|
|
};
|
|
|
|
// Keep the same function ID so we can remove it later
|
|
newFunc.guid = fn.guid;
|
|
|
|
_this3.on(target, type, newFunc);
|
|
})();
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Trigger an event on an element
|
|
* ```js
|
|
* myComponent.trigger('eventName');
|
|
* myComponent.trigger({'type':'eventName'});
|
|
* myComponent.trigger('eventName', {data: 'some data'});
|
|
* myComponent.trigger({'type':'eventName'}, {data: 'some data'});
|
|
* ```
|
|
*
|
|
* @param {Event|Object|String} event A string (the type) or an event object with a type attribute
|
|
* @param {Object} [hash] data hash to pass along with the event
|
|
* @return {Component} self
|
|
* @method trigger
|
|
*/
|
|
|
|
Component.prototype.trigger = function trigger(event, hash) {
|
|
Events.trigger(this.el_, event, hash);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Bind a listener to the component's ready state.
|
|
* Different from event listeners in that if the ready event has already happened
|
|
* it will trigger the function immediately.
|
|
*
|
|
* @param {Function} fn Ready listener
|
|
* @param {Boolean} sync Exec the listener synchronously if component is ready
|
|
* @return {Component}
|
|
* @method ready
|
|
*/
|
|
|
|
Component.prototype.ready = function ready(fn) {
|
|
var sync = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
|
|
|
|
if (fn) {
|
|
if (this.isReady_) {
|
|
if (sync) {
|
|
fn.call(this);
|
|
} else {
|
|
// Call the function asynchronously by default for consistency
|
|
this.setTimeout(fn, 1);
|
|
}
|
|
} else {
|
|
this.readyQueue_ = this.readyQueue_ || [];
|
|
this.readyQueue_.push(fn);
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Trigger the ready listeners
|
|
*
|
|
* @return {Component}
|
|
* @method triggerReady
|
|
*/
|
|
|
|
Component.prototype.triggerReady = function triggerReady() {
|
|
this.isReady_ = true;
|
|
|
|
// Ensure ready is triggerd asynchronously
|
|
this.setTimeout(function () {
|
|
var readyQueue = this.readyQueue_;
|
|
|
|
// Reset Ready Queue
|
|
this.readyQueue_ = [];
|
|
|
|
if (readyQueue && readyQueue.length > 0) {
|
|
readyQueue.forEach(function (fn) {
|
|
fn.call(this);
|
|
}, this);
|
|
}
|
|
|
|
// Allow for using event listeners also
|
|
this.trigger('ready');
|
|
}, 1);
|
|
};
|
|
|
|
/**
|
|
* Finds a single DOM element matching `selector` within the component's
|
|
* `contentEl` or another custom context.
|
|
*
|
|
* @method $
|
|
* @param {String} selector
|
|
* A valid CSS selector, which will be passed to `querySelector`.
|
|
*
|
|
* @param {Element|String} [context=document]
|
|
* A DOM element within which to query. Can also be a selector
|
|
* string in which case the first matching element will be used
|
|
* as context. If missing (or no element matches selector), falls
|
|
* back to `document`.
|
|
*
|
|
* @return {Element|null}
|
|
*/
|
|
|
|
Component.prototype.$ = function $(selector, context) {
|
|
return Dom.$(selector, context || this.contentEl());
|
|
};
|
|
|
|
/**
|
|
* Finds a all DOM elements matching `selector` within the component's
|
|
* `contentEl` or another custom context.
|
|
*
|
|
* @method $$
|
|
* @param {String} selector
|
|
* A valid CSS selector, which will be passed to `querySelectorAll`.
|
|
*
|
|
* @param {Element|String} [context=document]
|
|
* A DOM element within which to query. Can also be a selector
|
|
* string in which case the first matching element will be used
|
|
* as context. If missing (or no element matches selector), falls
|
|
* back to `document`.
|
|
*
|
|
* @return {NodeList}
|
|
*/
|
|
|
|
Component.prototype.$$ = function $$(selector, context) {
|
|
return Dom.$$(selector, context || this.contentEl());
|
|
};
|
|
|
|
/**
|
|
* Check if a component's element has a CSS class name
|
|
*
|
|
* @param {String} classToCheck Classname to check
|
|
* @return {Component}
|
|
* @method hasClass
|
|
*/
|
|
|
|
Component.prototype.hasClass = function hasClass(classToCheck) {
|
|
return Dom.hasElClass(this.el_, classToCheck);
|
|
};
|
|
|
|
/**
|
|
* Add a CSS class name to the component's element
|
|
*
|
|
* @param {String} classToAdd Classname to add
|
|
* @return {Component}
|
|
* @method addClass
|
|
*/
|
|
|
|
Component.prototype.addClass = function addClass(classToAdd) {
|
|
Dom.addElClass(this.el_, classToAdd);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove a CSS class name from the component's element
|
|
*
|
|
* @param {String} classToRemove Classname to remove
|
|
* @return {Component}
|
|
* @method removeClass
|
|
*/
|
|
|
|
Component.prototype.removeClass = function removeClass(classToRemove) {
|
|
Dom.removeElClass(this.el_, classToRemove);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add or remove a CSS class name from the component's element
|
|
*
|
|
* @param {String} classToToggle
|
|
* @param {Boolean|Function} [predicate]
|
|
* Can be a function that returns a Boolean. If `true`, the class
|
|
* will be added; if `false`, the class will be removed. If not
|
|
* given, the class will be added if not present and vice versa.
|
|
*
|
|
* @return {Component}
|
|
* @method toggleClass
|
|
*/
|
|
|
|
Component.prototype.toggleClass = function toggleClass(classToToggle, predicate) {
|
|
Dom.toggleElClass(this.el_, classToToggle, predicate);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Show the component element if hidden
|
|
*
|
|
* @return {Component}
|
|
* @method show
|
|
*/
|
|
|
|
Component.prototype.show = function show() {
|
|
this.removeClass('vjs-hidden');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Hide the component element if currently showing
|
|
*
|
|
* @return {Component}
|
|
* @method hide
|
|
*/
|
|
|
|
Component.prototype.hide = function hide() {
|
|
this.addClass('vjs-hidden');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Lock an item in its visible state
|
|
* To be used with fadeIn/fadeOut.
|
|
*
|
|
* @return {Component}
|
|
* @private
|
|
* @method lockShowing
|
|
*/
|
|
|
|
Component.prototype.lockShowing = function lockShowing() {
|
|
this.addClass('vjs-lock-showing');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Unlock an item to be hidden
|
|
* To be used with fadeIn/fadeOut.
|
|
*
|
|
* @return {Component}
|
|
* @private
|
|
* @method unlockShowing
|
|
*/
|
|
|
|
Component.prototype.unlockShowing = function unlockShowing() {
|
|
this.removeClass('vjs-lock-showing');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set or get the width of the component (CSS values)
|
|
* Setting the video tag dimension values only works with values in pixels.
|
|
* Percent values will not work.
|
|
* Some percents can be used, but width()/height() will return the number + %,
|
|
* not the actual computed width/height.
|
|
*
|
|
* @param {Number|String=} num Optional width number
|
|
* @param {Boolean} skipListeners Skip the 'resize' event trigger
|
|
* @return {Component} This component, when setting the width
|
|
* @return {Number|String} The width, when getting
|
|
* @method width
|
|
*/
|
|
|
|
Component.prototype.width = function width(num, skipListeners) {
|
|
return this.dimension('width', num, skipListeners);
|
|
};
|
|
|
|
/**
|
|
* Get or set the height of the component (CSS values)
|
|
* Setting the video tag dimension values only works with values in pixels.
|
|
* Percent values will not work.
|
|
* Some percents can be used, but width()/height() will return the number + %,
|
|
* not the actual computed width/height.
|
|
*
|
|
* @param {Number|String=} num New component height
|
|
* @param {Boolean=} skipListeners Skip the resize event trigger
|
|
* @return {Component} This component, when setting the height
|
|
* @return {Number|String} The height, when getting
|
|
* @method height
|
|
*/
|
|
|
|
Component.prototype.height = function height(num, skipListeners) {
|
|
return this.dimension('height', num, skipListeners);
|
|
};
|
|
|
|
/**
|
|
* Set both width and height at the same time
|
|
*
|
|
* @param {Number|String} width Width of player
|
|
* @param {Number|String} height Height of player
|
|
* @return {Component} The component
|
|
* @method dimensions
|
|
*/
|
|
|
|
Component.prototype.dimensions = function dimensions(width, height) {
|
|
// Skip resize listeners on width for optimization
|
|
return this.width(width, true).height(height);
|
|
};
|
|
|
|
/**
|
|
* Get or set width or height
|
|
* This is the shared code for the width() and height() methods.
|
|
* All for an integer, integer + 'px' or integer + '%';
|
|
* Known issue: Hidden elements officially have a width of 0. We're defaulting
|
|
* to the style.width value and falling back to computedStyle which has the
|
|
* hidden element issue. Info, but probably not an efficient fix:
|
|
* http://www.foliotek.com/devblog/getting-the-width-of-a-hidden-element-with-jquery-using-width/
|
|
*
|
|
* @param {String} widthOrHeight 'width' or 'height'
|
|
* @param {Number|String=} num New dimension
|
|
* @param {Boolean=} skipListeners Skip resize event trigger
|
|
* @return {Component} The component if a dimension was set
|
|
* @return {Number|String} The dimension if nothing was set
|
|
* @private
|
|
* @method dimension
|
|
*/
|
|
|
|
Component.prototype.dimension = function dimension(widthOrHeight, num, skipListeners) {
|
|
if (num !== undefined) {
|
|
// Set to zero if null or literally NaN (NaN !== NaN)
|
|
if (num === null || num !== num) {
|
|
num = 0;
|
|
}
|
|
|
|
// Check if using css width/height (% or px) and adjust
|
|
if (('' + num).indexOf('%') !== -1 || ('' + num).indexOf('px') !== -1) {
|
|
this.el_.style[widthOrHeight] = num;
|
|
} else if (num === 'auto') {
|
|
this.el_.style[widthOrHeight] = '';
|
|
} else {
|
|
this.el_.style[widthOrHeight] = num + 'px';
|
|
}
|
|
|
|
// skipListeners allows us to avoid triggering the resize event when setting both width and height
|
|
if (!skipListeners) {
|
|
this.trigger('resize');
|
|
}
|
|
|
|
// Return component
|
|
return this;
|
|
}
|
|
|
|
// Not setting a value, so getting it
|
|
// Make sure element exists
|
|
if (!this.el_) {
|
|
return 0;
|
|
}
|
|
|
|
// Get dimension value from style
|
|
var val = this.el_.style[widthOrHeight];
|
|
var pxIndex = val.indexOf('px');
|
|
|
|
if (pxIndex !== -1) {
|
|
// Return the pixel value with no 'px'
|
|
return parseInt(val.slice(0, pxIndex), 10);
|
|
}
|
|
|
|
// No px so using % or no style was set, so falling back to offsetWidth/height
|
|
// If component has display:none, offset will return 0
|
|
// TODO: handle display:none and no dimension style using px
|
|
return parseInt(this.el_['offset' + _utilsToTitleCaseJs2['default'](widthOrHeight)], 10);
|
|
};
|
|
|
|
/**
|
|
* Get width or height of computed style
|
|
* @param {String} widthOrHeight 'width' or 'height'
|
|
* @return {Number|Boolean} The bolean false if nothing was set
|
|
* @method currentDimension
|
|
*/
|
|
|
|
Component.prototype.currentDimension = function currentDimension(widthOrHeight) {
|
|
var computedWidthOrHeight = 0;
|
|
|
|
if (widthOrHeight !== 'width' && widthOrHeight !== 'height') {
|
|
throw new Error('currentDimension only accepts width or height value');
|
|
}
|
|
|
|
if (typeof _globalWindow2['default'].getComputedStyle === 'function') {
|
|
var computedStyle = _globalWindow2['default'].getComputedStyle(this.el_);
|
|
computedWidthOrHeight = computedStyle.getPropertyValue(widthOrHeight) || computedStyle[widthOrHeight];
|
|
} else if (this.el_.currentStyle) {
|
|
// ie 8 doesn't support computed style, shim it
|
|
// return clientWidth or clientHeight instead for better accuracy
|
|
var rule = 'offset' + _utilsToTitleCaseJs2['default'](widthOrHeight);
|
|
computedWidthOrHeight = this.el_[rule];
|
|
}
|
|
|
|
// remove 'px' from variable and parse as integer
|
|
computedWidthOrHeight = parseFloat(computedWidthOrHeight);
|
|
return computedWidthOrHeight;
|
|
};
|
|
|
|
/**
|
|
* Get an object which contains width and height values of computed style
|
|
* @return {Object} The dimensions of element
|
|
* @method currentDimensions
|
|
*/
|
|
|
|
Component.prototype.currentDimensions = function currentDimensions() {
|
|
return {
|
|
width: this.currentDimension('width'),
|
|
height: this.currentDimension('height')
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Get width of computed style
|
|
* @return {Integer}
|
|
* @method currentWidth
|
|
*/
|
|
|
|
Component.prototype.currentWidth = function currentWidth() {
|
|
return this.currentDimension('width');
|
|
};
|
|
|
|
/**
|
|
* Get height of computed style
|
|
* @return {Integer}
|
|
* @method currentHeight
|
|
*/
|
|
|
|
Component.prototype.currentHeight = function currentHeight() {
|
|
return this.currentDimension('height');
|
|
};
|
|
|
|
/**
|
|
* Emit 'tap' events when touch events are supported
|
|
* This is used to support toggling the controls through a tap on the video.
|
|
* We're requiring them to be enabled because otherwise every component would
|
|
* have this extra overhead unnecessarily, on mobile devices where extra
|
|
* overhead is especially bad.
|
|
*
|
|
* @private
|
|
* @method emitTapEvents
|
|
*/
|
|
|
|
Component.prototype.emitTapEvents = function emitTapEvents() {
|
|
// Track the start time so we can determine how long the touch lasted
|
|
var touchStart = 0;
|
|
var firstTouch = null;
|
|
|
|
// Maximum movement allowed during a touch event to still be considered a tap
|
|
// Other popular libs use anywhere from 2 (hammer.js) to 15, so 10 seems like a nice, round number.
|
|
var tapMovementThreshold = 10;
|
|
|
|
// The maximum length a touch can be while still being considered a tap
|
|
var touchTimeThreshold = 200;
|
|
|
|
var couldBeTap = undefined;
|
|
|
|
this.on('touchstart', function (event) {
|
|
// If more than one finger, don't consider treating this as a click
|
|
if (event.touches.length === 1) {
|
|
// Copy the touches object to prevent modifying the original
|
|
firstTouch = _objectAssign2['default']({}, event.touches[0]);
|
|
// Record start time so we can detect a tap vs. "touch and hold"
|
|
touchStart = new Date().getTime();
|
|
// Reset couldBeTap tracking
|
|
couldBeTap = true;
|
|
}
|
|
});
|
|
|
|
this.on('touchmove', function (event) {
|
|
// If more than one finger, don't consider treating this as a click
|
|
if (event.touches.length > 1) {
|
|
couldBeTap = false;
|
|
} else if (firstTouch) {
|
|
// Some devices will throw touchmoves for all but the slightest of taps.
|
|
// So, if we moved only a small distance, this could still be a tap
|
|
var xdiff = event.touches[0].pageX - firstTouch.pageX;
|
|
var ydiff = event.touches[0].pageY - firstTouch.pageY;
|
|
var touchDistance = Math.sqrt(xdiff * xdiff + ydiff * ydiff);
|
|
|
|
if (touchDistance > tapMovementThreshold) {
|
|
couldBeTap = false;
|
|
}
|
|
}
|
|
});
|
|
|
|
var noTap = function noTap() {
|
|
couldBeTap = false;
|
|
};
|
|
|
|
// TODO: Listen to the original target. http://youtu.be/DujfpXOKUp8?t=13m8s
|
|
this.on('touchleave', noTap);
|
|
this.on('touchcancel', noTap);
|
|
|
|
// When the touch ends, measure how long it took and trigger the appropriate
|
|
// event
|
|
this.on('touchend', function (event) {
|
|
firstTouch = null;
|
|
// Proceed only if the touchmove/leave/cancel event didn't happen
|
|
if (couldBeTap === true) {
|
|
// Measure how long the touch lasted
|
|
var touchTime = new Date().getTime() - touchStart;
|
|
|
|
// Make sure the touch was less than the threshold to be considered a tap
|
|
if (touchTime < touchTimeThreshold) {
|
|
// Don't let browser turn this into a click
|
|
event.preventDefault();
|
|
this.trigger('tap');
|
|
// It may be good to copy the touchend event object and change the
|
|
// type to tap, if the other event properties aren't exact after
|
|
// Events.fixEvent runs (e.g. event.target)
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Report user touch activity when touch events occur
|
|
* User activity is used to determine when controls should show/hide. It's
|
|
* relatively simple when it comes to mouse events, because any mouse event
|
|
* should show the controls. So we capture mouse events that bubble up to the
|
|
* player and report activity when that happens.
|
|
* With touch events it isn't as easy. We can't rely on touch events at the
|
|
* player level, because a tap (touchstart + touchend) on the video itself on
|
|
* mobile devices is meant to turn controls off (and on). User activity is
|
|
* checked asynchronously, so what could happen is a tap event on the video
|
|
* turns the controls off, then the touchend event bubbles up to the player,
|
|
* which if it reported user activity, would turn the controls right back on.
|
|
* (We also don't want to completely block touch events from bubbling up)
|
|
* Also a touchmove, touch+hold, and anything other than a tap is not supposed
|
|
* to turn the controls back on on a mobile device.
|
|
* Here we're setting the default component behavior to report user activity
|
|
* whenever touch events happen, and this can be turned off by components that
|
|
* want touch events to act differently.
|
|
*
|
|
* @method enableTouchActivity
|
|
*/
|
|
|
|
Component.prototype.enableTouchActivity = function enableTouchActivity() {
|
|
// Don't continue if the root player doesn't support reporting user activity
|
|
if (!this.player() || !this.player().reportUserActivity) {
|
|
return;
|
|
}
|
|
|
|
// listener for reporting that the user is active
|
|
var report = Fn.bind(this.player(), this.player().reportUserActivity);
|
|
|
|
var touchHolding = undefined;
|
|
|
|
this.on('touchstart', function () {
|
|
report();
|
|
// For as long as the they are touching the device or have their mouse down,
|
|
// we consider them active even if they're not moving their finger or mouse.
|
|
// So we want to continue to update that they are active
|
|
this.clearInterval(touchHolding);
|
|
// report at the same interval as activityCheck
|
|
touchHolding = this.setInterval(report, 250);
|
|
});
|
|
|
|
var touchEnd = function touchEnd(event) {
|
|
report();
|
|
// stop the interval that maintains activity if the touch is holding
|
|
this.clearInterval(touchHolding);
|
|
};
|
|
|
|
this.on('touchmove', report);
|
|
this.on('touchend', touchEnd);
|
|
this.on('touchcancel', touchEnd);
|
|
};
|
|
|
|
/**
|
|
* Creates timeout and sets up disposal automatically.
|
|
*
|
|
* @param {Function} fn The function to run after the timeout.
|
|
* @param {Number} timeout Number of ms to delay before executing specified function.
|
|
* @return {Number} Returns the timeout ID
|
|
* @method setTimeout
|
|
*/
|
|
|
|
Component.prototype.setTimeout = function setTimeout(fn, timeout) {
|
|
fn = Fn.bind(this, fn);
|
|
|
|
// window.setTimeout would be preferable here, but due to some bizarre issue with Sinon and/or Phantomjs, we can't.
|
|
var timeoutId = _globalWindow2['default'].setTimeout(fn, timeout);
|
|
|
|
var disposeFn = function disposeFn() {
|
|
this.clearTimeout(timeoutId);
|
|
};
|
|
|
|
disposeFn.guid = 'vjs-timeout-' + timeoutId;
|
|
|
|
this.on('dispose', disposeFn);
|
|
|
|
return timeoutId;
|
|
};
|
|
|
|
/**
|
|
* Clears a timeout and removes the associated dispose listener
|
|
*
|
|
* @param {Number} timeoutId The id of the timeout to clear
|
|
* @return {Number} Returns the timeout ID
|
|
* @method clearTimeout
|
|
*/
|
|
|
|
Component.prototype.clearTimeout = function clearTimeout(timeoutId) {
|
|
_globalWindow2['default'].clearTimeout(timeoutId);
|
|
|
|
var disposeFn = function disposeFn() {};
|
|
|
|
disposeFn.guid = 'vjs-timeout-' + timeoutId;
|
|
|
|
this.off('dispose', disposeFn);
|
|
|
|
return timeoutId;
|
|
};
|
|
|
|
/**
|
|
* Creates an interval and sets up disposal automatically.
|
|
*
|
|
* @param {Function} fn The function to run every N seconds.
|
|
* @param {Number} interval Number of ms to delay before executing specified function.
|
|
* @return {Number} Returns the interval ID
|
|
* @method setInterval
|
|
*/
|
|
|
|
Component.prototype.setInterval = function setInterval(fn, interval) {
|
|
fn = Fn.bind(this, fn);
|
|
|
|
var intervalId = _globalWindow2['default'].setInterval(fn, interval);
|
|
|
|
var disposeFn = function disposeFn() {
|
|
this.clearInterval(intervalId);
|
|
};
|
|
|
|
disposeFn.guid = 'vjs-interval-' + intervalId;
|
|
|
|
this.on('dispose', disposeFn);
|
|
|
|
return intervalId;
|
|
};
|
|
|
|
/**
|
|
* Clears an interval and removes the associated dispose listener
|
|
*
|
|
* @param {Number} intervalId The id of the interval to clear
|
|
* @return {Number} Returns the interval ID
|
|
* @method clearInterval
|
|
*/
|
|
|
|
Component.prototype.clearInterval = function clearInterval(intervalId) {
|
|
_globalWindow2['default'].clearInterval(intervalId);
|
|
|
|
var disposeFn = function disposeFn() {};
|
|
|
|
disposeFn.guid = 'vjs-interval-' + intervalId;
|
|
|
|
this.off('dispose', disposeFn);
|
|
|
|
return intervalId;
|
|
};
|
|
|
|
/**
|
|
* Registers a component
|
|
*
|
|
* @param {String} name Name of the component to register
|
|
* @param {Object} comp The component to register
|
|
* @static
|
|
* @method registerComponent
|
|
*/
|
|
|
|
Component.registerComponent = function registerComponent(name, comp) {
|
|
if (!Component.components_) {
|
|
Component.components_ = {};
|
|
}
|
|
|
|
Component.components_[name] = comp;
|
|
return comp;
|
|
};
|
|
|
|
/**
|
|
* Gets a component by name
|
|
*
|
|
* @param {String} name Name of the component to get
|
|
* @return {Component}
|
|
* @static
|
|
* @method getComponent
|
|
*/
|
|
|
|
Component.getComponent = function getComponent(name) {
|
|
if (Component.components_ && Component.components_[name]) {
|
|
return Component.components_[name];
|
|
}
|
|
|
|
if (_globalWindow2['default'] && _globalWindow2['default'].videojs && _globalWindow2['default'].videojs[name]) {
|
|
_utilsLogJs2['default'].warn('The ' + name + ' component was added to the videojs object when it should be registered using videojs.registerComponent(name, component)');
|
|
return _globalWindow2['default'].videojs[name];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sets up the constructor using the supplied init method
|
|
* or uses the init of the parent object
|
|
*
|
|
* @param {Object} props An object of properties
|
|
* @static
|
|
* @deprecated
|
|
* @method extend
|
|
*/
|
|
|
|
Component.extend = function extend(props) {
|
|
props = props || {};
|
|
|
|
_utilsLogJs2['default'].warn('Component.extend({}) has been deprecated, use videojs.extend(Component, {}) instead');
|
|
|
|
// Set up the constructor using the supplied init method
|
|
// or using the init of the parent object
|
|
// Make sure to check the unobfuscated version for external libs
|
|
var init = props.init || props.init || this.prototype.init || this.prototype.init || function () {};
|
|
// In Resig's simple class inheritance (previously used) the constructor
|
|
// is a function that calls `this.init.apply(arguments)`
|
|
// However that would prevent us from using `ParentObject.call(this);`
|
|
// in a Child constructor because the `this` in `this.init`
|
|
// would still refer to the Child and cause an infinite loop.
|
|
// We would instead have to do
|
|
// `ParentObject.prototype.init.apply(this, arguments);`
|
|
// Bleh. We're not creating a _super() function, so it's good to keep
|
|
// the parent constructor reference simple.
|
|
var subObj = function subObj() {
|
|
init.apply(this, arguments);
|
|
};
|
|
|
|
// Inherit from this object's prototype
|
|
subObj.prototype = Object.create(this.prototype);
|
|
// Reset the constructor property for subObj otherwise
|
|
// instances of subObj would have the constructor of the parent Object
|
|
subObj.prototype.constructor = subObj;
|
|
|
|
// Make the class extendable
|
|
subObj.extend = Component.extend;
|
|
|
|
// Extend subObj's prototype with functions and other properties from props
|
|
for (var _name in props) {
|
|
if (props.hasOwnProperty(_name)) {
|
|
subObj.prototype[_name] = props[_name];
|
|
}
|
|
}
|
|
|
|
return subObj;
|
|
};
|
|
|
|
return Component;
|
|
})();
|
|
|
|
Component.registerComponent('Component', Component);
|
|
exports['default'] = Component;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./utils/dom.js":143,"./utils/events.js":144,"./utils/fn.js":145,"./utils/guid.js":147,"./utils/log.js":148,"./utils/merge-options.js":149,"./utils/to-title-case.js":152,"global/window":2,"object.assign":45}],68:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file audio-track-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackButtonJs = _dereq_('../track-button.js');
|
|
|
|
var _trackButtonJs2 = _interopRequireDefault(_trackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _audioTrackMenuItemJs = _dereq_('./audio-track-menu-item.js');
|
|
|
|
var _audioTrackMenuItemJs2 = _interopRequireDefault(_audioTrackMenuItemJs);
|
|
|
|
/**
|
|
* The base class for buttons that toggle specific text track types (e.g. subtitles)
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends TrackButton
|
|
* @class AudioTrackButton
|
|
*/
|
|
|
|
var AudioTrackButton = (function (_TrackButton) {
|
|
_inherits(AudioTrackButton, _TrackButton);
|
|
|
|
function AudioTrackButton(player) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
_classCallCheck(this, AudioTrackButton);
|
|
|
|
options.tracks = player.audioTracks && player.audioTracks();
|
|
|
|
_TrackButton.call(this, player, options);
|
|
|
|
this.el_.setAttribute('aria-label', 'Audio Menu');
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
AudioTrackButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-audio-button ' + _TrackButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create a menu item for each audio track
|
|
*
|
|
* @return {Array} Array of menu items
|
|
* @method createItems
|
|
*/
|
|
|
|
AudioTrackButton.prototype.createItems = function createItems() {
|
|
var items = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
var tracks = this.player_.audioTracks && this.player_.audioTracks();
|
|
|
|
if (!tracks) {
|
|
return items;
|
|
}
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
|
|
items.push(new _audioTrackMenuItemJs2['default'](this.player_, {
|
|
// MenuItem is selectable
|
|
'selectable': true,
|
|
'track': track
|
|
}));
|
|
}
|
|
|
|
return items;
|
|
};
|
|
|
|
return AudioTrackButton;
|
|
})(_trackButtonJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('AudioTrackButton', AudioTrackButton);
|
|
exports['default'] = AudioTrackButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/fn.js":145,"../track-button.js":98,"./audio-track-menu-item.js":69}],69:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file audio-track-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _menuMenuItemJs = _dereq_('../../menu/menu-item.js');
|
|
|
|
var _menuMenuItemJs2 = _interopRequireDefault(_menuMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
/**
|
|
* The audio track menu item
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuItem
|
|
* @class AudioTrackMenuItem
|
|
*/
|
|
|
|
var AudioTrackMenuItem = (function (_MenuItem) {
|
|
_inherits(AudioTrackMenuItem, _MenuItem);
|
|
|
|
function AudioTrackMenuItem(player, options) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, AudioTrackMenuItem);
|
|
|
|
var track = options.track;
|
|
var tracks = player.audioTracks();
|
|
|
|
// Modify options for parent MenuItem class's init.
|
|
options.label = track.label || track.language || 'Unknown';
|
|
options.selected = track.enabled;
|
|
|
|
_MenuItem.call(this, player, options);
|
|
|
|
this.track = track;
|
|
|
|
if (tracks) {
|
|
(function () {
|
|
var changeHandler = Fn.bind(_this, _this.handleTracksChange);
|
|
|
|
tracks.addEventListener('change', changeHandler);
|
|
_this.on('dispose', function () {
|
|
tracks.removeEventListener('change', changeHandler);
|
|
});
|
|
})();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle click on audio track
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
AudioTrackMenuItem.prototype.handleClick = function handleClick(event) {
|
|
var tracks = this.player_.audioTracks();
|
|
|
|
_MenuItem.prototype.handleClick.call(this, event);
|
|
|
|
if (!tracks) return;
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
|
|
if (track === this.track) {
|
|
track.enabled = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle audio track change
|
|
*
|
|
* @method handleTracksChange
|
|
*/
|
|
|
|
AudioTrackMenuItem.prototype.handleTracksChange = function handleTracksChange(event) {
|
|
this.selected(this.track.enabled);
|
|
};
|
|
|
|
return AudioTrackMenuItem;
|
|
})(_menuMenuItemJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('AudioTrackMenuItem', AudioTrackMenuItem);
|
|
exports['default'] = AudioTrackMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu-item.js":110,"../../utils/fn.js":145}],70:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file control-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
// Required children
|
|
|
|
var _playToggleJs = _dereq_('./play-toggle.js');
|
|
|
|
var _playToggleJs2 = _interopRequireDefault(_playToggleJs);
|
|
|
|
var _timeControlsCurrentTimeDisplayJs = _dereq_('./time-controls/current-time-display.js');
|
|
|
|
var _timeControlsCurrentTimeDisplayJs2 = _interopRequireDefault(_timeControlsCurrentTimeDisplayJs);
|
|
|
|
var _timeControlsDurationDisplayJs = _dereq_('./time-controls/duration-display.js');
|
|
|
|
var _timeControlsDurationDisplayJs2 = _interopRequireDefault(_timeControlsDurationDisplayJs);
|
|
|
|
var _timeControlsTimeDividerJs = _dereq_('./time-controls/time-divider.js');
|
|
|
|
var _timeControlsTimeDividerJs2 = _interopRequireDefault(_timeControlsTimeDividerJs);
|
|
|
|
var _timeControlsRemainingTimeDisplayJs = _dereq_('./time-controls/remaining-time-display.js');
|
|
|
|
var _timeControlsRemainingTimeDisplayJs2 = _interopRequireDefault(_timeControlsRemainingTimeDisplayJs);
|
|
|
|
var _liveDisplayJs = _dereq_('./live-display.js');
|
|
|
|
var _liveDisplayJs2 = _interopRequireDefault(_liveDisplayJs);
|
|
|
|
var _progressControlProgressControlJs = _dereq_('./progress-control/progress-control.js');
|
|
|
|
var _progressControlProgressControlJs2 = _interopRequireDefault(_progressControlProgressControlJs);
|
|
|
|
var _fullscreenToggleJs = _dereq_('./fullscreen-toggle.js');
|
|
|
|
var _fullscreenToggleJs2 = _interopRequireDefault(_fullscreenToggleJs);
|
|
|
|
var _volumeControlVolumeControlJs = _dereq_('./volume-control/volume-control.js');
|
|
|
|
var _volumeControlVolumeControlJs2 = _interopRequireDefault(_volumeControlVolumeControlJs);
|
|
|
|
var _volumeMenuButtonJs = _dereq_('./volume-menu-button.js');
|
|
|
|
var _volumeMenuButtonJs2 = _interopRequireDefault(_volumeMenuButtonJs);
|
|
|
|
var _muteToggleJs = _dereq_('./mute-toggle.js');
|
|
|
|
var _muteToggleJs2 = _interopRequireDefault(_muteToggleJs);
|
|
|
|
var _textTrackControlsChaptersButtonJs = _dereq_('./text-track-controls/chapters-button.js');
|
|
|
|
var _textTrackControlsChaptersButtonJs2 = _interopRequireDefault(_textTrackControlsChaptersButtonJs);
|
|
|
|
var _textTrackControlsDescriptionsButtonJs = _dereq_('./text-track-controls/descriptions-button.js');
|
|
|
|
var _textTrackControlsDescriptionsButtonJs2 = _interopRequireDefault(_textTrackControlsDescriptionsButtonJs);
|
|
|
|
var _textTrackControlsSubtitlesButtonJs = _dereq_('./text-track-controls/subtitles-button.js');
|
|
|
|
var _textTrackControlsSubtitlesButtonJs2 = _interopRequireDefault(_textTrackControlsSubtitlesButtonJs);
|
|
|
|
var _textTrackControlsCaptionsButtonJs = _dereq_('./text-track-controls/captions-button.js');
|
|
|
|
var _textTrackControlsCaptionsButtonJs2 = _interopRequireDefault(_textTrackControlsCaptionsButtonJs);
|
|
|
|
var _audioTrackControlsAudioTrackButtonJs = _dereq_('./audio-track-controls/audio-track-button.js');
|
|
|
|
var _audioTrackControlsAudioTrackButtonJs2 = _interopRequireDefault(_audioTrackControlsAudioTrackButtonJs);
|
|
|
|
var _playbackRateMenuPlaybackRateMenuButtonJs = _dereq_('./playback-rate-menu/playback-rate-menu-button.js');
|
|
|
|
var _playbackRateMenuPlaybackRateMenuButtonJs2 = _interopRequireDefault(_playbackRateMenuPlaybackRateMenuButtonJs);
|
|
|
|
var _spacerControlsCustomControlSpacerJs = _dereq_('./spacer-controls/custom-control-spacer.js');
|
|
|
|
var _spacerControlsCustomControlSpacerJs2 = _interopRequireDefault(_spacerControlsCustomControlSpacerJs);
|
|
|
|
/**
|
|
* Container of main controls
|
|
*
|
|
* @extends Component
|
|
* @class ControlBar
|
|
*/
|
|
|
|
var ControlBar = (function (_Component) {
|
|
_inherits(ControlBar, _Component);
|
|
|
|
function ControlBar() {
|
|
_classCallCheck(this, ControlBar);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
ControlBar.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-control-bar',
|
|
dir: 'ltr'
|
|
}, {
|
|
'role': 'group' // The control bar is a group, so it can contain menuitems
|
|
});
|
|
};
|
|
|
|
return ControlBar;
|
|
})(_componentJs2['default']);
|
|
|
|
ControlBar.prototype.options_ = {
|
|
loadEvent: 'play',
|
|
children: ['playToggle', 'volumeMenuButton', 'currentTimeDisplay', 'timeDivider', 'durationDisplay', 'progressControl', 'liveDisplay', 'remainingTimeDisplay', 'customControlSpacer', 'playbackRateMenuButton', 'chaptersButton', 'descriptionsButton', 'subtitlesButton', 'captionsButton', 'audioTrackButton', 'fullscreenToggle']
|
|
};
|
|
|
|
_componentJs2['default'].registerComponent('ControlBar', ControlBar);
|
|
exports['default'] = ControlBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"./audio-track-controls/audio-track-button.js":68,"./fullscreen-toggle.js":71,"./live-display.js":72,"./mute-toggle.js":73,"./play-toggle.js":74,"./playback-rate-menu/playback-rate-menu-button.js":75,"./progress-control/progress-control.js":80,"./spacer-controls/custom-control-spacer.js":83,"./text-track-controls/captions-button.js":86,"./text-track-controls/chapters-button.js":87,"./text-track-controls/descriptions-button.js":89,"./text-track-controls/subtitles-button.js":91,"./time-controls/current-time-display.js":94,"./time-controls/duration-display.js":95,"./time-controls/remaining-time-display.js":96,"./time-controls/time-divider.js":97,"./volume-control/volume-control.js":100,"./volume-menu-button.js":102}],71:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file fullscreen-toggle.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _buttonJs = _dereq_('../button.js');
|
|
|
|
var _buttonJs2 = _interopRequireDefault(_buttonJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Toggle fullscreen video
|
|
*
|
|
* @extends Button
|
|
* @class FullscreenToggle
|
|
*/
|
|
|
|
var FullscreenToggle = (function (_Button) {
|
|
_inherits(FullscreenToggle, _Button);
|
|
|
|
function FullscreenToggle() {
|
|
_classCallCheck(this, FullscreenToggle);
|
|
|
|
_Button.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
FullscreenToggle.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-fullscreen-control ' + _Button.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Handles click for full screen
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
FullscreenToggle.prototype.handleClick = function handleClick() {
|
|
if (!this.player_.isFullscreen()) {
|
|
this.player_.requestFullscreen();
|
|
this.controlText('Non-Fullscreen');
|
|
} else {
|
|
this.player_.exitFullscreen();
|
|
this.controlText('Fullscreen');
|
|
}
|
|
};
|
|
|
|
return FullscreenToggle;
|
|
})(_buttonJs2['default']);
|
|
|
|
FullscreenToggle.prototype.controlText_ = 'Fullscreen';
|
|
|
|
_componentJs2['default'].registerComponent('FullscreenToggle', FullscreenToggle);
|
|
exports['default'] = FullscreenToggle;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../button.js":64,"../component.js":67}],72:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file live-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
/**
|
|
* Displays the live indicator
|
|
* TODO - Future make it click to snap to live
|
|
*
|
|
* @extends Component
|
|
* @class LiveDisplay
|
|
*/
|
|
|
|
var LiveDisplay = (function (_Component) {
|
|
_inherits(LiveDisplay, _Component);
|
|
|
|
function LiveDisplay(player, options) {
|
|
_classCallCheck(this, LiveDisplay);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
this.updateShowing();
|
|
this.on(this.player(), 'durationchange', this.updateShowing);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
LiveDisplay.prototype.createEl = function createEl() {
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-live-control vjs-control'
|
|
});
|
|
|
|
this.contentEl_ = Dom.createEl('div', {
|
|
className: 'vjs-live-display',
|
|
innerHTML: '<span class="vjs-control-text">' + this.localize('Stream Type') + '</span>' + this.localize('LIVE')
|
|
}, {
|
|
'aria-live': 'off'
|
|
});
|
|
|
|
el.appendChild(this.contentEl_);
|
|
return el;
|
|
};
|
|
|
|
LiveDisplay.prototype.updateShowing = function updateShowing() {
|
|
if (this.player().duration() === Infinity) {
|
|
this.show();
|
|
} else {
|
|
this.hide();
|
|
}
|
|
};
|
|
|
|
return LiveDisplay;
|
|
})(_component2['default']);
|
|
|
|
_component2['default'].registerComponent('LiveDisplay', LiveDisplay);
|
|
exports['default'] = LiveDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component":67,"../utils/dom.js":143}],73:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file mute-toggle.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _button = _dereq_('../button');
|
|
|
|
var _button2 = _interopRequireDefault(_button);
|
|
|
|
var _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
/**
|
|
* A button component for muting the audio
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Button
|
|
* @class MuteToggle
|
|
*/
|
|
|
|
var MuteToggle = (function (_Button) {
|
|
_inherits(MuteToggle, _Button);
|
|
|
|
function MuteToggle(player, options) {
|
|
_classCallCheck(this, MuteToggle);
|
|
|
|
_Button.call(this, player, options);
|
|
|
|
this.on(player, 'volumechange', this.update);
|
|
|
|
// hide mute toggle if the current tech doesn't support volume control
|
|
if (player.tech_ && player.tech_['featuresVolumeControl'] === false) {
|
|
this.addClass('vjs-hidden');
|
|
}
|
|
|
|
this.on(player, 'loadstart', function () {
|
|
this.update(); // We need to update the button to account for a default muted state.
|
|
|
|
if (player.tech_['featuresVolumeControl'] === false) {
|
|
this.addClass('vjs-hidden');
|
|
} else {
|
|
this.removeClass('vjs-hidden');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
MuteToggle.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-mute-control ' + _Button.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Handle click on mute
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
MuteToggle.prototype.handleClick = function handleClick() {
|
|
this.player_.muted(this.player_.muted() ? false : true);
|
|
};
|
|
|
|
/**
|
|
* Update volume
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
MuteToggle.prototype.update = function update() {
|
|
var vol = this.player_.volume(),
|
|
level = 3;
|
|
|
|
if (vol === 0 || this.player_.muted()) {
|
|
level = 0;
|
|
} else if (vol < 0.33) {
|
|
level = 1;
|
|
} else if (vol < 0.67) {
|
|
level = 2;
|
|
}
|
|
|
|
// Don't rewrite the button text if the actual text doesn't change.
|
|
// This causes unnecessary and confusing information for screen reader users.
|
|
// This check is needed because this function gets called every time the volume level is changed.
|
|
var toMute = this.player_.muted() ? 'Unmute' : 'Mute';
|
|
if (this.controlText() !== toMute) {
|
|
this.controlText(toMute);
|
|
}
|
|
|
|
/* TODO improve muted icon classes */
|
|
for (var i = 0; i < 4; i++) {
|
|
Dom.removeElClass(this.el_, 'vjs-vol-' + i);
|
|
}
|
|
Dom.addElClass(this.el_, 'vjs-vol-' + level);
|
|
};
|
|
|
|
return MuteToggle;
|
|
})(_button2['default']);
|
|
|
|
MuteToggle.prototype.controlText_ = 'Mute';
|
|
|
|
_component2['default'].registerComponent('MuteToggle', MuteToggle);
|
|
exports['default'] = MuteToggle;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../button":64,"../component":67,"../utils/dom.js":143}],74:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file play-toggle.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _buttonJs = _dereq_('../button.js');
|
|
|
|
var _buttonJs2 = _interopRequireDefault(_buttonJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Button to toggle between play and pause
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Button
|
|
* @class PlayToggle
|
|
*/
|
|
|
|
var PlayToggle = (function (_Button) {
|
|
_inherits(PlayToggle, _Button);
|
|
|
|
function PlayToggle(player, options) {
|
|
_classCallCheck(this, PlayToggle);
|
|
|
|
_Button.call(this, player, options);
|
|
|
|
this.on(player, 'play', this.handlePlay);
|
|
this.on(player, 'pause', this.handlePause);
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
PlayToggle.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-play-control ' + _Button.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Handle click to toggle between play and pause
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
PlayToggle.prototype.handleClick = function handleClick() {
|
|
if (this.player_.paused()) {
|
|
this.player_.play();
|
|
} else {
|
|
this.player_.pause();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add the vjs-playing class to the element so it can change appearance
|
|
*
|
|
* @method handlePlay
|
|
*/
|
|
|
|
PlayToggle.prototype.handlePlay = function handlePlay() {
|
|
this.removeClass('vjs-paused');
|
|
this.addClass('vjs-playing');
|
|
this.controlText('Pause'); // change the button text to "Pause"
|
|
};
|
|
|
|
/**
|
|
* Add the vjs-paused class to the element so it can change appearance
|
|
*
|
|
* @method handlePause
|
|
*/
|
|
|
|
PlayToggle.prototype.handlePause = function handlePause() {
|
|
this.removeClass('vjs-playing');
|
|
this.addClass('vjs-paused');
|
|
this.controlText('Play'); // change the button text to "Play"
|
|
};
|
|
|
|
return PlayToggle;
|
|
})(_buttonJs2['default']);
|
|
|
|
PlayToggle.prototype.controlText_ = 'Play';
|
|
|
|
_componentJs2['default'].registerComponent('PlayToggle', PlayToggle);
|
|
exports['default'] = PlayToggle;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../button.js":64,"../component.js":67}],75:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file playback-rate-menu-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _menuMenuButtonJs = _dereq_('../../menu/menu-button.js');
|
|
|
|
var _menuMenuButtonJs2 = _interopRequireDefault(_menuMenuButtonJs);
|
|
|
|
var _menuMenuJs = _dereq_('../../menu/menu.js');
|
|
|
|
var _menuMenuJs2 = _interopRequireDefault(_menuMenuJs);
|
|
|
|
var _playbackRateMenuItemJs = _dereq_('./playback-rate-menu-item.js');
|
|
|
|
var _playbackRateMenuItemJs2 = _interopRequireDefault(_playbackRateMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
/**
|
|
* The component for controlling the playback rate
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuButton
|
|
* @class PlaybackRateMenuButton
|
|
*/
|
|
|
|
var PlaybackRateMenuButton = (function (_MenuButton) {
|
|
_inherits(PlaybackRateMenuButton, _MenuButton);
|
|
|
|
function PlaybackRateMenuButton(player, options) {
|
|
_classCallCheck(this, PlaybackRateMenuButton);
|
|
|
|
_MenuButton.call(this, player, options);
|
|
|
|
this.updateVisibility();
|
|
this.updateLabel();
|
|
|
|
this.on(player, 'loadstart', this.updateVisibility);
|
|
this.on(player, 'ratechange', this.updateLabel);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.createEl = function createEl() {
|
|
var el = _MenuButton.prototype.createEl.call(this);
|
|
|
|
this.labelEl_ = Dom.createEl('div', {
|
|
className: 'vjs-playback-rate-value',
|
|
innerHTML: 1.0
|
|
});
|
|
|
|
el.appendChild(this.labelEl_);
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-playback-rate ' + _MenuButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the playback rate menu
|
|
*
|
|
* @return {Menu} Menu object populated with items
|
|
* @method createMenu
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.createMenu = function createMenu() {
|
|
var menu = new _menuMenuJs2['default'](this.player());
|
|
var rates = this.playbackRates();
|
|
|
|
if (rates) {
|
|
for (var i = rates.length - 1; i >= 0; i--) {
|
|
menu.addChild(new _playbackRateMenuItemJs2['default'](this.player(), { 'rate': rates[i] + 'x' }));
|
|
}
|
|
}
|
|
|
|
return menu;
|
|
};
|
|
|
|
/**
|
|
* Updates ARIA accessibility attributes
|
|
*
|
|
* @method updateARIAAttributes
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.updateARIAAttributes = function updateARIAAttributes() {
|
|
// Current playback rate
|
|
this.el().setAttribute('aria-valuenow', this.player().playbackRate());
|
|
};
|
|
|
|
/**
|
|
* Handle menu item click
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.handleClick = function handleClick() {
|
|
// select next rate option
|
|
var currentRate = this.player().playbackRate();
|
|
var rates = this.playbackRates();
|
|
|
|
// this will select first one if the last one currently selected
|
|
var newRate = rates[0];
|
|
for (var i = 0; i < rates.length; i++) {
|
|
if (rates[i] > currentRate) {
|
|
newRate = rates[i];
|
|
break;
|
|
}
|
|
}
|
|
this.player().playbackRate(newRate);
|
|
};
|
|
|
|
/**
|
|
* Get possible playback rates
|
|
*
|
|
* @return {Array} Possible playback rates
|
|
* @method playbackRates
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.playbackRates = function playbackRates() {
|
|
return this.options_['playbackRates'] || this.options_.playerOptions && this.options_.playerOptions['playbackRates'];
|
|
};
|
|
|
|
/**
|
|
* Get whether playback rates is supported by the tech
|
|
* and an array of playback rates exists
|
|
*
|
|
* @return {Boolean} Whether changing playback rate is supported
|
|
* @method playbackRateSupported
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.playbackRateSupported = function playbackRateSupported() {
|
|
return this.player().tech_ && this.player().tech_['featuresPlaybackRate'] && this.playbackRates() && this.playbackRates().length > 0;
|
|
};
|
|
|
|
/**
|
|
* Hide playback rate controls when they're no playback rate options to select
|
|
*
|
|
* @method updateVisibility
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.updateVisibility = function updateVisibility() {
|
|
if (this.playbackRateSupported()) {
|
|
this.removeClass('vjs-hidden');
|
|
} else {
|
|
this.addClass('vjs-hidden');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update button label when rate changed
|
|
*
|
|
* @method updateLabel
|
|
*/
|
|
|
|
PlaybackRateMenuButton.prototype.updateLabel = function updateLabel() {
|
|
if (this.playbackRateSupported()) {
|
|
this.labelEl_.innerHTML = this.player().playbackRate() + 'x';
|
|
}
|
|
};
|
|
|
|
return PlaybackRateMenuButton;
|
|
})(_menuMenuButtonJs2['default']);
|
|
|
|
PlaybackRateMenuButton.prototype.controlText_ = 'Playback Rate';
|
|
|
|
_componentJs2['default'].registerComponent('PlaybackRateMenuButton', PlaybackRateMenuButton);
|
|
exports['default'] = PlaybackRateMenuButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu-button.js":109,"../../menu/menu.js":111,"../../utils/dom.js":143,"./playback-rate-menu-item.js":76}],76:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file playback-rate-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _menuMenuItemJs = _dereq_('../../menu/menu-item.js');
|
|
|
|
var _menuMenuItemJs2 = _interopRequireDefault(_menuMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* The specific menu item type for selecting a playback rate
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuItem
|
|
* @class PlaybackRateMenuItem
|
|
*/
|
|
|
|
var PlaybackRateMenuItem = (function (_MenuItem) {
|
|
_inherits(PlaybackRateMenuItem, _MenuItem);
|
|
|
|
function PlaybackRateMenuItem(player, options) {
|
|
_classCallCheck(this, PlaybackRateMenuItem);
|
|
|
|
var label = options['rate'];
|
|
var rate = parseFloat(label, 10);
|
|
|
|
// Modify options for parent MenuItem class's init.
|
|
options['label'] = label;
|
|
options['selected'] = rate === 1;
|
|
_MenuItem.call(this, player, options);
|
|
|
|
this.label = label;
|
|
this.rate = rate;
|
|
|
|
this.on(player, 'ratechange', this.update);
|
|
}
|
|
|
|
/**
|
|
* Handle click on menu item
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
PlaybackRateMenuItem.prototype.handleClick = function handleClick() {
|
|
_MenuItem.prototype.handleClick.call(this);
|
|
this.player().playbackRate(this.rate);
|
|
};
|
|
|
|
/**
|
|
* Update playback rate with selected rate
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
PlaybackRateMenuItem.prototype.update = function update() {
|
|
this.selected(this.player().playbackRate() === this.rate);
|
|
};
|
|
|
|
return PlaybackRateMenuItem;
|
|
})(_menuMenuItemJs2['default']);
|
|
|
|
PlaybackRateMenuItem.prototype.contentElType = 'button';
|
|
|
|
_componentJs2['default'].registerComponent('PlaybackRateMenuItem', PlaybackRateMenuItem);
|
|
exports['default'] = PlaybackRateMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu-item.js":110}],77:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file load-progress-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
/**
|
|
* Shows load progress
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class LoadProgressBar
|
|
*/
|
|
|
|
var LoadProgressBar = (function (_Component) {
|
|
_inherits(LoadProgressBar, _Component);
|
|
|
|
function LoadProgressBar(player, options) {
|
|
_classCallCheck(this, LoadProgressBar);
|
|
|
|
_Component.call(this, player, options);
|
|
this.on(player, 'progress', this.update);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
LoadProgressBar.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-load-progress',
|
|
innerHTML: '<span class="vjs-control-text"><span>' + this.localize('Loaded') + '</span>: 0%</span>'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Update progress bar
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
LoadProgressBar.prototype.update = function update() {
|
|
var buffered = this.player_.buffered();
|
|
var duration = this.player_.duration();
|
|
var bufferedEnd = this.player_.bufferedEnd();
|
|
var children = this.el_.children;
|
|
|
|
// get the percent width of a time compared to the total end
|
|
var percentify = function percentify(time, end) {
|
|
var percent = time / end || 0; // no NaN
|
|
return (percent >= 1 ? 1 : percent) * 100 + '%';
|
|
};
|
|
|
|
// update the width of the progress bar
|
|
this.el_.style.width = percentify(bufferedEnd, duration);
|
|
|
|
// add child elements to represent the individual buffered time ranges
|
|
for (var i = 0; i < buffered.length; i++) {
|
|
var start = buffered.start(i);
|
|
var end = buffered.end(i);
|
|
var part = children[i];
|
|
|
|
if (!part) {
|
|
part = this.el_.appendChild(Dom.createEl());
|
|
}
|
|
|
|
// set the percent based on the width of the progress bar (bufferedEnd)
|
|
part.style.left = percentify(start, bufferedEnd);
|
|
part.style.width = percentify(end - start, bufferedEnd);
|
|
}
|
|
|
|
// remove unused buffered range elements
|
|
for (var i = children.length; i > buffered.length; i--) {
|
|
this.el_.removeChild(children[i - 1]);
|
|
}
|
|
};
|
|
|
|
return LoadProgressBar;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('LoadProgressBar', LoadProgressBar);
|
|
exports['default'] = LoadProgressBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143}],78:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file mouse-time-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
var _lodashCompatFunctionThrottle = _dereq_('lodash-compat/function/throttle');
|
|
|
|
var _lodashCompatFunctionThrottle2 = _interopRequireDefault(_lodashCompatFunctionThrottle);
|
|
|
|
/**
|
|
* The Mouse Time Display component shows the time you will seek to
|
|
* when hovering over the progress bar
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class MouseTimeDisplay
|
|
*/
|
|
|
|
var MouseTimeDisplay = (function (_Component) {
|
|
_inherits(MouseTimeDisplay, _Component);
|
|
|
|
function MouseTimeDisplay(player, options) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, MouseTimeDisplay);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
if (options.playerOptions && options.playerOptions.controlBar && options.playerOptions.controlBar.progressControl && options.playerOptions.controlBar.progressControl.keepTooltipsInside) {
|
|
this.keepTooltipsInside = options.playerOptions.controlBar.progressControl.keepTooltipsInside;
|
|
}
|
|
|
|
if (this.keepTooltipsInside) {
|
|
this.tooltip = Dom.createEl('div', { className: 'vjs-time-tooltip' });
|
|
this.el().appendChild(this.tooltip);
|
|
this.addClass('vjs-keep-tooltips-inside');
|
|
}
|
|
|
|
this.update(0, 0);
|
|
|
|
player.on('ready', function () {
|
|
_this.on(player.controlBar.progressControl.el(), 'mousemove', _lodashCompatFunctionThrottle2['default'](Fn.bind(_this, _this.handleMouseMove), 25));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
MouseTimeDisplay.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-mouse-display'
|
|
});
|
|
};
|
|
|
|
MouseTimeDisplay.prototype.handleMouseMove = function handleMouseMove(event) {
|
|
var duration = this.player_.duration();
|
|
var newTime = this.calculateDistance(event) * duration;
|
|
var position = event.pageX - Dom.findElPosition(this.el().parentNode).left;
|
|
|
|
this.update(newTime, position);
|
|
};
|
|
|
|
MouseTimeDisplay.prototype.update = function update(newTime, position) {
|
|
var time = _utilsFormatTimeJs2['default'](newTime, this.player_.duration());
|
|
|
|
this.el().style.left = position + 'px';
|
|
this.el().setAttribute('data-current-time', time);
|
|
|
|
if (this.keepTooltipsInside) {
|
|
var clampedPosition = this.clampPosition_(position);
|
|
var difference = position - clampedPosition + 1;
|
|
var tooltipWidth = parseFloat(_globalWindow2['default'].getComputedStyle(this.tooltip).width);
|
|
var tooltipWidthHalf = tooltipWidth / 2;
|
|
|
|
this.tooltip.innerHTML = time;
|
|
this.tooltip.style.right = '-' + (tooltipWidthHalf - difference) + 'px';
|
|
}
|
|
};
|
|
|
|
MouseTimeDisplay.prototype.calculateDistance = function calculateDistance(event) {
|
|
return Dom.getPointerPosition(this.el().parentNode, event).x;
|
|
};
|
|
|
|
/**
|
|
* This takes in a horizontal position for the bar and returns a clamped position.
|
|
* Clamped position means that it will keep the position greater than half the width
|
|
* of the tooltip and smaller than the player width minus half the width o the tooltip.
|
|
* It will only clamp the position if `keepTooltipsInside` option is set.
|
|
*
|
|
* @param {Number} position the position the bar wants to be
|
|
* @return {Number} newPosition the (potentially) clamped position
|
|
* @method clampPosition_
|
|
*/
|
|
|
|
MouseTimeDisplay.prototype.clampPosition_ = function clampPosition_(position) {
|
|
if (!this.keepTooltipsInside) {
|
|
return position;
|
|
}
|
|
|
|
var playerWidth = parseFloat(_globalWindow2['default'].getComputedStyle(this.player().el()).width);
|
|
var tooltipWidth = parseFloat(_globalWindow2['default'].getComputedStyle(this.tooltip).width);
|
|
var tooltipWidthHalf = tooltipWidth / 2;
|
|
var actualPosition = position;
|
|
|
|
if (position < tooltipWidthHalf) {
|
|
actualPosition = Math.ceil(tooltipWidthHalf);
|
|
} else if (position > playerWidth - tooltipWidthHalf) {
|
|
actualPosition = Math.floor(playerWidth - tooltipWidthHalf);
|
|
}
|
|
|
|
return actualPosition;
|
|
};
|
|
|
|
return MouseTimeDisplay;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('MouseTimeDisplay', MouseTimeDisplay);
|
|
exports['default'] = MouseTimeDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/fn.js":145,"../../utils/format-time.js":146,"global/window":2,"lodash-compat/function/throttle":7}],79:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file play-progress-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
/**
|
|
* Shows play progress
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class PlayProgressBar
|
|
*/
|
|
|
|
var PlayProgressBar = (function (_Component) {
|
|
_inherits(PlayProgressBar, _Component);
|
|
|
|
function PlayProgressBar(player, options) {
|
|
_classCallCheck(this, PlayProgressBar);
|
|
|
|
_Component.call(this, player, options);
|
|
this.updateDataAttr();
|
|
this.on(player, 'timeupdate', this.updateDataAttr);
|
|
player.ready(Fn.bind(this, this.updateDataAttr));
|
|
|
|
if (options.playerOptions && options.playerOptions.controlBar && options.playerOptions.controlBar.progressControl && options.playerOptions.controlBar.progressControl.keepTooltipsInside) {
|
|
this.keepTooltipsInside = options.playerOptions.controlBar.progressControl.keepTooltipsInside;
|
|
}
|
|
|
|
if (this.keepTooltipsInside) {
|
|
this.addClass('vjs-keep-tooltips-inside');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
PlayProgressBar.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-play-progress vjs-slider-bar',
|
|
innerHTML: '<span class="vjs-control-text"><span>' + this.localize('Progress') + '</span>: 0%</span>'
|
|
});
|
|
};
|
|
|
|
PlayProgressBar.prototype.updateDataAttr = function updateDataAttr() {
|
|
var time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
|
|
this.el_.setAttribute('data-current-time', _utilsFormatTimeJs2['default'](time, this.player_.duration()));
|
|
};
|
|
|
|
return PlayProgressBar;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('PlayProgressBar', PlayProgressBar);
|
|
exports['default'] = PlayProgressBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/fn.js":145,"../../utils/format-time.js":146}],80:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file progress-control.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _seekBarJs = _dereq_('./seek-bar.js');
|
|
|
|
var _seekBarJs2 = _interopRequireDefault(_seekBarJs);
|
|
|
|
var _mouseTimeDisplayJs = _dereq_('./mouse-time-display.js');
|
|
|
|
var _mouseTimeDisplayJs2 = _interopRequireDefault(_mouseTimeDisplayJs);
|
|
|
|
/**
|
|
* The Progress Control component contains the seek bar, load progress,
|
|
* and play progress
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class ProgressControl
|
|
*/
|
|
|
|
var ProgressControl = (function (_Component) {
|
|
_inherits(ProgressControl, _Component);
|
|
|
|
function ProgressControl() {
|
|
_classCallCheck(this, ProgressControl);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
ProgressControl.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-progress-control vjs-control'
|
|
});
|
|
};
|
|
|
|
return ProgressControl;
|
|
})(_componentJs2['default']);
|
|
|
|
ProgressControl.prototype.options_ = {
|
|
children: ['seekBar']
|
|
};
|
|
|
|
_componentJs2['default'].registerComponent('ProgressControl', ProgressControl);
|
|
exports['default'] = ProgressControl;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./mouse-time-display.js":78,"./seek-bar.js":81}],81:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file seek-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _sliderSliderJs = _dereq_('../../slider/slider.js');
|
|
|
|
var _sliderSliderJs2 = _interopRequireDefault(_sliderSliderJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _loadProgressBarJs = _dereq_('./load-progress-bar.js');
|
|
|
|
var _loadProgressBarJs2 = _interopRequireDefault(_loadProgressBarJs);
|
|
|
|
var _playProgressBarJs = _dereq_('./play-progress-bar.js');
|
|
|
|
var _playProgressBarJs2 = _interopRequireDefault(_playProgressBarJs);
|
|
|
|
var _tooltipProgressBarJs = _dereq_('./tooltip-progress-bar.js');
|
|
|
|
var _tooltipProgressBarJs2 = _interopRequireDefault(_tooltipProgressBarJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/**
|
|
* Seek Bar and holder for the progress bars
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Slider
|
|
* @class SeekBar
|
|
*/
|
|
|
|
var SeekBar = (function (_Slider) {
|
|
_inherits(SeekBar, _Slider);
|
|
|
|
function SeekBar(player, options) {
|
|
_classCallCheck(this, SeekBar);
|
|
|
|
_Slider.call(this, player, options);
|
|
this.on(player, 'timeupdate', this.updateProgress);
|
|
this.on(player, 'ended', this.updateProgress);
|
|
player.ready(Fn.bind(this, this.updateProgress));
|
|
|
|
if (options.playerOptions && options.playerOptions.controlBar && options.playerOptions.controlBar.progressControl && options.playerOptions.controlBar.progressControl.keepTooltipsInside) {
|
|
this.keepTooltipsInside = options.playerOptions.controlBar.progressControl.keepTooltipsInside;
|
|
}
|
|
|
|
if (this.keepTooltipsInside) {
|
|
this.tooltipProgressBar = this.addChild('TooltipProgressBar');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
SeekBar.prototype.createEl = function createEl() {
|
|
return _Slider.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-progress-holder'
|
|
}, {
|
|
'aria-label': 'progress bar'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Update ARIA accessibility attributes
|
|
*
|
|
* @method updateARIAAttributes
|
|
*/
|
|
|
|
SeekBar.prototype.updateProgress = function updateProgress() {
|
|
this.updateAriaAttributes(this.el_);
|
|
|
|
if (this.keepTooltipsInside) {
|
|
this.updateAriaAttributes(this.tooltipProgressBar.el_);
|
|
this.tooltipProgressBar.el_.style.width = this.bar.el_.style.width;
|
|
|
|
var playerWidth = parseFloat(_globalWindow2['default'].getComputedStyle(this.player().el()).width);
|
|
var tooltipWidth = parseFloat(_globalWindow2['default'].getComputedStyle(this.tooltipProgressBar.tooltip).width);
|
|
var tooltipStyle = this.tooltipProgressBar.el().style;
|
|
tooltipStyle.maxWidth = Math.floor(playerWidth - tooltipWidth / 2) + 'px';
|
|
tooltipStyle.minWidth = Math.ceil(tooltipWidth / 2) + 'px';
|
|
tooltipStyle.right = '-' + tooltipWidth / 2 + 'px';
|
|
}
|
|
};
|
|
|
|
SeekBar.prototype.updateAriaAttributes = function updateAriaAttributes(el) {
|
|
// Allows for smooth scrubbing, when player can't keep up.
|
|
var time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
|
|
el.setAttribute('aria-valuenow', (this.getPercent() * 100).toFixed(2)); // machine readable value of progress bar (percentage complete)
|
|
el.setAttribute('aria-valuetext', _utilsFormatTimeJs2['default'](time, this.player_.duration())); // human readable value of progress bar (time complete)
|
|
};
|
|
|
|
/**
|
|
* Get percentage of video played
|
|
*
|
|
* @return {Number} Percentage played
|
|
* @method getPercent
|
|
*/
|
|
|
|
SeekBar.prototype.getPercent = function getPercent() {
|
|
var percent = this.player_.currentTime() / this.player_.duration();
|
|
return percent >= 1 ? 1 : percent;
|
|
};
|
|
|
|
/**
|
|
* Handle mouse down on seek bar
|
|
*
|
|
* @method handleMouseDown
|
|
*/
|
|
|
|
SeekBar.prototype.handleMouseDown = function handleMouseDown(event) {
|
|
_Slider.prototype.handleMouseDown.call(this, event);
|
|
|
|
this.player_.scrubbing(true);
|
|
|
|
this.videoWasPlaying = !this.player_.paused();
|
|
this.player_.pause();
|
|
};
|
|
|
|
/**
|
|
* Handle mouse move on seek bar
|
|
*
|
|
* @method handleMouseMove
|
|
*/
|
|
|
|
SeekBar.prototype.handleMouseMove = function handleMouseMove(event) {
|
|
var newTime = this.calculateDistance(event) * this.player_.duration();
|
|
|
|
// Don't let video end while scrubbing.
|
|
if (newTime === this.player_.duration()) {
|
|
newTime = newTime - 0.1;
|
|
}
|
|
|
|
// Set new time (tell player to seek to new time)
|
|
this.player_.currentTime(newTime);
|
|
};
|
|
|
|
/**
|
|
* Handle mouse up on seek bar
|
|
*
|
|
* @method handleMouseUp
|
|
*/
|
|
|
|
SeekBar.prototype.handleMouseUp = function handleMouseUp(event) {
|
|
_Slider.prototype.handleMouseUp.call(this, event);
|
|
|
|
this.player_.scrubbing(false);
|
|
if (this.videoWasPlaying) {
|
|
this.player_.play();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Move more quickly fast forward for keyboard-only users
|
|
*
|
|
* @method stepForward
|
|
*/
|
|
|
|
SeekBar.prototype.stepForward = function stepForward() {
|
|
this.player_.currentTime(this.player_.currentTime() + 5); // more quickly fast forward for keyboard-only users
|
|
};
|
|
|
|
/**
|
|
* Move more quickly rewind for keyboard-only users
|
|
*
|
|
* @method stepBack
|
|
*/
|
|
|
|
SeekBar.prototype.stepBack = function stepBack() {
|
|
this.player_.currentTime(this.player_.currentTime() - 5); // more quickly rewind for keyboard-only users
|
|
};
|
|
|
|
return SeekBar;
|
|
})(_sliderSliderJs2['default']);
|
|
|
|
SeekBar.prototype.options_ = {
|
|
children: ['loadProgressBar', 'mouseTimeDisplay', 'playProgressBar'],
|
|
'barName': 'playProgressBar'
|
|
};
|
|
|
|
SeekBar.prototype.playerEvent = 'timeupdate';
|
|
|
|
_componentJs2['default'].registerComponent('SeekBar', SeekBar);
|
|
exports['default'] = SeekBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../slider/slider.js":119,"../../utils/fn.js":145,"../../utils/format-time.js":146,"./load-progress-bar.js":77,"./play-progress-bar.js":79,"./tooltip-progress-bar.js":82,"global/window":2,"object.assign":45}],82:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file play-progress-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
/**
|
|
* Shows play progress
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class PlayProgressBar
|
|
*/
|
|
|
|
var TooltipProgressBar = (function (_Component) {
|
|
_inherits(TooltipProgressBar, _Component);
|
|
|
|
function TooltipProgressBar(player, options) {
|
|
_classCallCheck(this, TooltipProgressBar);
|
|
|
|
_Component.call(this, player, options);
|
|
this.updateDataAttr();
|
|
this.on(player, 'timeupdate', this.updateDataAttr);
|
|
player.ready(Fn.bind(this, this.updateDataAttr));
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
TooltipProgressBar.prototype.createEl = function createEl() {
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-tooltip-progress-bar vjs-slider-bar',
|
|
innerHTML: '<div class="vjs-time-tooltip"></div>\n <span class="vjs-control-text"><span>' + this.localize('Progress') + '</span>: 0%</span>'
|
|
});
|
|
|
|
this.tooltip = el.querySelector('.vjs-time-tooltip');
|
|
|
|
return el;
|
|
};
|
|
|
|
TooltipProgressBar.prototype.updateDataAttr = function updateDataAttr() {
|
|
var time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
|
|
var formattedTime = _utilsFormatTimeJs2['default'](time, this.player_.duration());
|
|
this.el_.setAttribute('data-current-time', formattedTime);
|
|
this.tooltip.innerHTML = formattedTime;
|
|
};
|
|
|
|
return TooltipProgressBar;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('TooltipProgressBar', TooltipProgressBar);
|
|
exports['default'] = TooltipProgressBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/fn.js":145,"../../utils/format-time.js":146}],83:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file custom-control-spacer.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _spacerJs = _dereq_('./spacer.js');
|
|
|
|
var _spacerJs2 = _interopRequireDefault(_spacerJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Spacer specifically meant to be used as an insertion point for new plugins, etc.
|
|
*
|
|
* @extends Spacer
|
|
* @class CustomControlSpacer
|
|
*/
|
|
|
|
var CustomControlSpacer = (function (_Spacer) {
|
|
_inherits(CustomControlSpacer, _Spacer);
|
|
|
|
function CustomControlSpacer() {
|
|
_classCallCheck(this, CustomControlSpacer);
|
|
|
|
_Spacer.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
CustomControlSpacer.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-custom-control-spacer ' + _Spacer.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
CustomControlSpacer.prototype.createEl = function createEl() {
|
|
var el = _Spacer.prototype.createEl.call(this, {
|
|
className: this.buildCSSClass()
|
|
});
|
|
|
|
// No-flex/table-cell mode requires there be some content
|
|
// in the cell to fill the remaining space of the table.
|
|
el.innerHTML = ' ';
|
|
return el;
|
|
};
|
|
|
|
return CustomControlSpacer;
|
|
})(_spacerJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('CustomControlSpacer', CustomControlSpacer);
|
|
exports['default'] = CustomControlSpacer;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./spacer.js":84}],84:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file spacer.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Just an empty spacer element that can be used as an append point for plugins, etc.
|
|
* Also can be used to create space between elements when necessary.
|
|
*
|
|
* @extends Component
|
|
* @class Spacer
|
|
*/
|
|
|
|
var Spacer = (function (_Component) {
|
|
_inherits(Spacer, _Component);
|
|
|
|
function Spacer() {
|
|
_classCallCheck(this, Spacer);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
Spacer.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-spacer ' + _Component.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Spacer.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: this.buildCSSClass()
|
|
});
|
|
};
|
|
|
|
return Spacer;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('Spacer', Spacer);
|
|
|
|
exports['default'] = Spacer;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67}],85:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file caption-settings-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _textTrackMenuItemJs = _dereq_('./text-track-menu-item.js');
|
|
|
|
var _textTrackMenuItemJs2 = _interopRequireDefault(_textTrackMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* The menu item for caption track settings menu
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends TextTrackMenuItem
|
|
* @class CaptionSettingsMenuItem
|
|
*/
|
|
|
|
var CaptionSettingsMenuItem = (function (_TextTrackMenuItem) {
|
|
_inherits(CaptionSettingsMenuItem, _TextTrackMenuItem);
|
|
|
|
function CaptionSettingsMenuItem(player, options) {
|
|
_classCallCheck(this, CaptionSettingsMenuItem);
|
|
|
|
options['track'] = {
|
|
'kind': options['kind'],
|
|
'player': player,
|
|
'label': options['kind'] + ' settings',
|
|
'selectable': false,
|
|
'default': false,
|
|
mode: 'disabled'
|
|
};
|
|
|
|
// CaptionSettingsMenuItem has no concept of 'selected'
|
|
options['selectable'] = false;
|
|
|
|
_TextTrackMenuItem.call(this, player, options);
|
|
this.addClass('vjs-texttrack-settings');
|
|
this.controlText(', opens ' + options['kind'] + ' settings dialog');
|
|
}
|
|
|
|
/**
|
|
* Handle click on menu item
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
CaptionSettingsMenuItem.prototype.handleClick = function handleClick() {
|
|
this.player().getChild('textTrackSettings').show();
|
|
this.player().getChild('textTrackSettings').el_.focus();
|
|
};
|
|
|
|
return CaptionSettingsMenuItem;
|
|
})(_textTrackMenuItemJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('CaptionSettingsMenuItem', CaptionSettingsMenuItem);
|
|
exports['default'] = CaptionSettingsMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./text-track-menu-item.js":93}],86:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file captions-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _textTrackButtonJs = _dereq_('./text-track-button.js');
|
|
|
|
var _textTrackButtonJs2 = _interopRequireDefault(_textTrackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _captionSettingsMenuItemJs = _dereq_('./caption-settings-menu-item.js');
|
|
|
|
var _captionSettingsMenuItemJs2 = _interopRequireDefault(_captionSettingsMenuItemJs);
|
|
|
|
/**
|
|
* The button component for toggling and selecting captions
|
|
*
|
|
* @param {Object} player Player object
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends TextTrackButton
|
|
* @class CaptionsButton
|
|
*/
|
|
|
|
var CaptionsButton = (function (_TextTrackButton) {
|
|
_inherits(CaptionsButton, _TextTrackButton);
|
|
|
|
function CaptionsButton(player, options, ready) {
|
|
_classCallCheck(this, CaptionsButton);
|
|
|
|
_TextTrackButton.call(this, player, options, ready);
|
|
this.el_.setAttribute('aria-label', 'Captions Menu');
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
CaptionsButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-captions-button ' + _TextTrackButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Update caption menu items
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
CaptionsButton.prototype.update = function update() {
|
|
var threshold = 2;
|
|
_TextTrackButton.prototype.update.call(this);
|
|
|
|
// if native, then threshold is 1 because no settings button
|
|
if (this.player().tech_ && this.player().tech_['featuresNativeTextTracks']) {
|
|
threshold = 1;
|
|
}
|
|
|
|
if (this.items && this.items.length > threshold) {
|
|
this.show();
|
|
} else {
|
|
this.hide();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create caption menu items
|
|
*
|
|
* @return {Array} Array of menu items
|
|
* @method createItems
|
|
*/
|
|
|
|
CaptionsButton.prototype.createItems = function createItems() {
|
|
var items = [];
|
|
|
|
if (!(this.player().tech_ && this.player().tech_['featuresNativeTextTracks'])) {
|
|
items.push(new _captionSettingsMenuItemJs2['default'](this.player_, { 'kind': this.kind_ }));
|
|
}
|
|
|
|
return _TextTrackButton.prototype.createItems.call(this, items);
|
|
};
|
|
|
|
return CaptionsButton;
|
|
})(_textTrackButtonJs2['default']);
|
|
|
|
CaptionsButton.prototype.kind_ = 'captions';
|
|
CaptionsButton.prototype.controlText_ = 'Captions';
|
|
|
|
_componentJs2['default'].registerComponent('CaptionsButton', CaptionsButton);
|
|
exports['default'] = CaptionsButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./caption-settings-menu-item.js":85,"./text-track-button.js":92}],87:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file chapters-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _textTrackButtonJs = _dereq_('./text-track-button.js');
|
|
|
|
var _textTrackButtonJs2 = _interopRequireDefault(_textTrackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _textTrackMenuItemJs = _dereq_('./text-track-menu-item.js');
|
|
|
|
var _textTrackMenuItemJs2 = _interopRequireDefault(_textTrackMenuItemJs);
|
|
|
|
var _chaptersTrackMenuItemJs = _dereq_('./chapters-track-menu-item.js');
|
|
|
|
var _chaptersTrackMenuItemJs2 = _interopRequireDefault(_chaptersTrackMenuItemJs);
|
|
|
|
var _menuMenuJs = _dereq_('../../menu/menu.js');
|
|
|
|
var _menuMenuJs2 = _interopRequireDefault(_menuMenuJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('../../utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
/**
|
|
* The button component for toggling and selecting chapters
|
|
* Chapters act much differently than other text tracks
|
|
* Cues are navigation vs. other tracks of alternative languages
|
|
*
|
|
* @param {Object} player Player object
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends TextTrackButton
|
|
* @class ChaptersButton
|
|
*/
|
|
|
|
var ChaptersButton = (function (_TextTrackButton) {
|
|
_inherits(ChaptersButton, _TextTrackButton);
|
|
|
|
function ChaptersButton(player, options, ready) {
|
|
_classCallCheck(this, ChaptersButton);
|
|
|
|
_TextTrackButton.call(this, player, options, ready);
|
|
this.el_.setAttribute('aria-label', 'Chapters Menu');
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
ChaptersButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-chapters-button ' + _TextTrackButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create a menu item for each text track
|
|
*
|
|
* @return {Array} Array of menu items
|
|
* @method createItems
|
|
*/
|
|
|
|
ChaptersButton.prototype.createItems = function createItems() {
|
|
var items = [];
|
|
|
|
var tracks = this.player_.textTracks();
|
|
|
|
if (!tracks) {
|
|
return items;
|
|
}
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
if (track['kind'] === this.kind_) {
|
|
items.push(new _textTrackMenuItemJs2['default'](this.player_, {
|
|
'track': track
|
|
}));
|
|
}
|
|
}
|
|
|
|
return items;
|
|
};
|
|
|
|
/**
|
|
* Create menu from chapter buttons
|
|
*
|
|
* @return {Menu} Menu of chapter buttons
|
|
* @method createMenu
|
|
*/
|
|
|
|
ChaptersButton.prototype.createMenu = function createMenu() {
|
|
var _this = this;
|
|
|
|
var tracks = this.player_.textTracks() || [];
|
|
var chaptersTrack = undefined;
|
|
var items = this.items = [];
|
|
|
|
for (var i = 0, _length = tracks.length; i < _length; i++) {
|
|
var track = tracks[i];
|
|
|
|
if (track['kind'] === this.kind_) {
|
|
chaptersTrack = track;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
var menu = this.menu;
|
|
if (menu === undefined) {
|
|
menu = new _menuMenuJs2['default'](this.player_);
|
|
var title = Dom.createEl('li', {
|
|
className: 'vjs-menu-title',
|
|
innerHTML: _utilsToTitleCaseJs2['default'](this.kind_),
|
|
tabIndex: -1
|
|
});
|
|
menu.children_.unshift(title);
|
|
Dom.insertElFirst(title, menu.contentEl());
|
|
}
|
|
|
|
if (chaptersTrack && chaptersTrack.cues == null) {
|
|
chaptersTrack['mode'] = 'hidden';
|
|
|
|
var remoteTextTrackEl = this.player_.remoteTextTrackEls().getTrackElementByTrack_(chaptersTrack);
|
|
|
|
if (remoteTextTrackEl) {
|
|
remoteTextTrackEl.addEventListener('load', function (event) {
|
|
return _this.update();
|
|
});
|
|
}
|
|
}
|
|
|
|
if (chaptersTrack && chaptersTrack.cues && chaptersTrack.cues.length > 0) {
|
|
var cues = chaptersTrack['cues'],
|
|
cue = undefined;
|
|
|
|
for (var i = 0, l = cues.length; i < l; i++) {
|
|
cue = cues[i];
|
|
|
|
var mi = new _chaptersTrackMenuItemJs2['default'](this.player_, {
|
|
'track': chaptersTrack,
|
|
'cue': cue
|
|
});
|
|
|
|
items.push(mi);
|
|
|
|
menu.addChild(mi);
|
|
}
|
|
|
|
this.addChild(menu);
|
|
}
|
|
|
|
if (this.items.length > 0) {
|
|
this.show();
|
|
}
|
|
|
|
return menu;
|
|
};
|
|
|
|
return ChaptersButton;
|
|
})(_textTrackButtonJs2['default']);
|
|
|
|
ChaptersButton.prototype.kind_ = 'chapters';
|
|
ChaptersButton.prototype.controlText_ = 'Chapters';
|
|
|
|
_componentJs2['default'].registerComponent('ChaptersButton', ChaptersButton);
|
|
exports['default'] = ChaptersButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu.js":111,"../../utils/dom.js":143,"../../utils/fn.js":145,"../../utils/to-title-case.js":152,"./chapters-track-menu-item.js":88,"./text-track-button.js":92,"./text-track-menu-item.js":93,"global/window":2}],88:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file chapters-track-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _menuMenuItemJs = _dereq_('../../menu/menu-item.js');
|
|
|
|
var _menuMenuItemJs2 = _interopRequireDefault(_menuMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
/**
|
|
* The chapter track menu item
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuItem
|
|
* @class ChaptersTrackMenuItem
|
|
*/
|
|
|
|
var ChaptersTrackMenuItem = (function (_MenuItem) {
|
|
_inherits(ChaptersTrackMenuItem, _MenuItem);
|
|
|
|
function ChaptersTrackMenuItem(player, options) {
|
|
_classCallCheck(this, ChaptersTrackMenuItem);
|
|
|
|
var track = options['track'];
|
|
var cue = options['cue'];
|
|
var currentTime = player.currentTime();
|
|
|
|
// Modify options for parent MenuItem class's init.
|
|
options['label'] = cue.text;
|
|
options['selected'] = cue['startTime'] <= currentTime && currentTime < cue['endTime'];
|
|
_MenuItem.call(this, player, options);
|
|
|
|
this.track = track;
|
|
this.cue = cue;
|
|
track.addEventListener('cuechange', Fn.bind(this, this.update));
|
|
}
|
|
|
|
/**
|
|
* Handle click on menu item
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
ChaptersTrackMenuItem.prototype.handleClick = function handleClick() {
|
|
_MenuItem.prototype.handleClick.call(this);
|
|
this.player_.currentTime(this.cue.startTime);
|
|
this.update(this.cue.startTime);
|
|
};
|
|
|
|
/**
|
|
* Update chapter menu item
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
ChaptersTrackMenuItem.prototype.update = function update() {
|
|
var cue = this.cue;
|
|
var currentTime = this.player_.currentTime();
|
|
|
|
// vjs.log(currentTime, cue.startTime);
|
|
this.selected(cue['startTime'] <= currentTime && currentTime < cue['endTime']);
|
|
};
|
|
|
|
return ChaptersTrackMenuItem;
|
|
})(_menuMenuItemJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('ChaptersTrackMenuItem', ChaptersTrackMenuItem);
|
|
exports['default'] = ChaptersTrackMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu-item.js":110,"../../utils/fn.js":145}],89:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file descriptions-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _textTrackButtonJs = _dereq_('./text-track-button.js');
|
|
|
|
var _textTrackButtonJs2 = _interopRequireDefault(_textTrackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
/**
|
|
* The button component for toggling and selecting descriptions
|
|
*
|
|
* @param {Object} player Player object
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends TextTrackButton
|
|
* @class DescriptionsButton
|
|
*/
|
|
|
|
var DescriptionsButton = (function (_TextTrackButton) {
|
|
_inherits(DescriptionsButton, _TextTrackButton);
|
|
|
|
function DescriptionsButton(player, options, ready) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, DescriptionsButton);
|
|
|
|
_TextTrackButton.call(this, player, options, ready);
|
|
this.el_.setAttribute('aria-label', 'Descriptions Menu');
|
|
|
|
var tracks = player.textTracks();
|
|
|
|
if (tracks) {
|
|
(function () {
|
|
var changeHandler = Fn.bind(_this, _this.handleTracksChange);
|
|
|
|
tracks.addEventListener('change', changeHandler);
|
|
_this.on('dispose', function () {
|
|
tracks.removeEventListener('change', changeHandler);
|
|
});
|
|
})();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle text track change
|
|
*
|
|
* @method handleTracksChange
|
|
*/
|
|
|
|
DescriptionsButton.prototype.handleTracksChange = function handleTracksChange(event) {
|
|
var tracks = this.player().textTracks();
|
|
var disabled = false;
|
|
|
|
// Check whether a track of a different kind is showing
|
|
for (var i = 0, l = tracks.length; i < l; i++) {
|
|
var track = tracks[i];
|
|
if (track['kind'] !== this.kind_ && track['mode'] === 'showing') {
|
|
disabled = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If another track is showing, disable this menu button
|
|
if (disabled) {
|
|
this.disable();
|
|
} else {
|
|
this.enable();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
DescriptionsButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-descriptions-button ' + _TextTrackButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
return DescriptionsButton;
|
|
})(_textTrackButtonJs2['default']);
|
|
|
|
DescriptionsButton.prototype.kind_ = 'descriptions';
|
|
DescriptionsButton.prototype.controlText_ = 'Descriptions';
|
|
|
|
_componentJs2['default'].registerComponent('DescriptionsButton', DescriptionsButton);
|
|
exports['default'] = DescriptionsButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/fn.js":145,"./text-track-button.js":92}],90:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file off-text-track-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _textTrackMenuItemJs = _dereq_('./text-track-menu-item.js');
|
|
|
|
var _textTrackMenuItemJs2 = _interopRequireDefault(_textTrackMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* A special menu item for turning of a specific type of text track
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends TextTrackMenuItem
|
|
* @class OffTextTrackMenuItem
|
|
*/
|
|
|
|
var OffTextTrackMenuItem = (function (_TextTrackMenuItem) {
|
|
_inherits(OffTextTrackMenuItem, _TextTrackMenuItem);
|
|
|
|
function OffTextTrackMenuItem(player, options) {
|
|
_classCallCheck(this, OffTextTrackMenuItem);
|
|
|
|
// Create pseudo track info
|
|
// Requires options['kind']
|
|
options['track'] = {
|
|
'kind': options['kind'],
|
|
'player': player,
|
|
'label': options['kind'] + ' off',
|
|
'default': false,
|
|
'mode': 'disabled'
|
|
};
|
|
|
|
// MenuItem is selectable
|
|
options['selectable'] = true;
|
|
|
|
_TextTrackMenuItem.call(this, player, options);
|
|
this.selected(true);
|
|
}
|
|
|
|
/**
|
|
* Handle text track change
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method handleTracksChange
|
|
*/
|
|
|
|
OffTextTrackMenuItem.prototype.handleTracksChange = function handleTracksChange(event) {
|
|
var tracks = this.player().textTracks();
|
|
var selected = true;
|
|
|
|
for (var i = 0, l = tracks.length; i < l; i++) {
|
|
var track = tracks[i];
|
|
if (track['kind'] === this.track['kind'] && track['mode'] === 'showing') {
|
|
selected = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.selected(selected);
|
|
};
|
|
|
|
return OffTextTrackMenuItem;
|
|
})(_textTrackMenuItemJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('OffTextTrackMenuItem', OffTextTrackMenuItem);
|
|
exports['default'] = OffTextTrackMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./text-track-menu-item.js":93}],91:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file subtitles-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _textTrackButtonJs = _dereq_('./text-track-button.js');
|
|
|
|
var _textTrackButtonJs2 = _interopRequireDefault(_textTrackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* The button component for toggling and selecting subtitles
|
|
*
|
|
* @param {Object} player Player object
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends TextTrackButton
|
|
* @class SubtitlesButton
|
|
*/
|
|
|
|
var SubtitlesButton = (function (_TextTrackButton) {
|
|
_inherits(SubtitlesButton, _TextTrackButton);
|
|
|
|
function SubtitlesButton(player, options, ready) {
|
|
_classCallCheck(this, SubtitlesButton);
|
|
|
|
_TextTrackButton.call(this, player, options, ready);
|
|
this.el_.setAttribute('aria-label', 'Subtitles Menu');
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
SubtitlesButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-subtitles-button ' + _TextTrackButton.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
return SubtitlesButton;
|
|
})(_textTrackButtonJs2['default']);
|
|
|
|
SubtitlesButton.prototype.kind_ = 'subtitles';
|
|
SubtitlesButton.prototype.controlText_ = 'Subtitles';
|
|
|
|
_componentJs2['default'].registerComponent('SubtitlesButton', SubtitlesButton);
|
|
exports['default'] = SubtitlesButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./text-track-button.js":92}],92:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackButtonJs = _dereq_('../track-button.js');
|
|
|
|
var _trackButtonJs2 = _interopRequireDefault(_trackButtonJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _textTrackMenuItemJs = _dereq_('./text-track-menu-item.js');
|
|
|
|
var _textTrackMenuItemJs2 = _interopRequireDefault(_textTrackMenuItemJs);
|
|
|
|
var _offTextTrackMenuItemJs = _dereq_('./off-text-track-menu-item.js');
|
|
|
|
var _offTextTrackMenuItemJs2 = _interopRequireDefault(_offTextTrackMenuItemJs);
|
|
|
|
/**
|
|
* The base class for buttons that toggle specific text track types (e.g. subtitles)
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuButton
|
|
* @class TextTrackButton
|
|
*/
|
|
|
|
var TextTrackButton = (function (_TrackButton) {
|
|
_inherits(TextTrackButton, _TrackButton);
|
|
|
|
function TextTrackButton(player) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
_classCallCheck(this, TextTrackButton);
|
|
|
|
options.tracks = player.textTracks();
|
|
|
|
_TrackButton.call(this, player, options);
|
|
}
|
|
|
|
/**
|
|
* Create a menu item for each text track
|
|
*
|
|
* @return {Array} Array of menu items
|
|
* @method createItems
|
|
*/
|
|
|
|
TextTrackButton.prototype.createItems = function createItems() {
|
|
var items = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
// Add an OFF menu item to turn all tracks off
|
|
items.push(new _offTextTrackMenuItemJs2['default'](this.player_, { 'kind': this.kind_ }));
|
|
|
|
var tracks = this.player_.textTracks();
|
|
|
|
if (!tracks) {
|
|
return items;
|
|
}
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
|
|
// only add tracks that are of the appropriate kind and have a label
|
|
if (track['kind'] === this.kind_) {
|
|
items.push(new _textTrackMenuItemJs2['default'](this.player_, {
|
|
// MenuItem is selectable
|
|
'selectable': true,
|
|
'track': track
|
|
}));
|
|
}
|
|
}
|
|
|
|
return items;
|
|
};
|
|
|
|
return TextTrackButton;
|
|
})(_trackButtonJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('TextTrackButton', TextTrackButton);
|
|
exports['default'] = TextTrackButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/fn.js":145,"../track-button.js":98,"./off-text-track-menu-item.js":90,"./text-track-menu-item.js":93}],93:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _menuMenuItemJs = _dereq_('../../menu/menu-item.js');
|
|
|
|
var _menuMenuItemJs2 = _interopRequireDefault(_menuMenuItemJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* The specific menu item type for selecting a language within a text track kind
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuItem
|
|
* @class TextTrackMenuItem
|
|
*/
|
|
|
|
var TextTrackMenuItem = (function (_MenuItem) {
|
|
_inherits(TextTrackMenuItem, _MenuItem);
|
|
|
|
function TextTrackMenuItem(player, options) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, TextTrackMenuItem);
|
|
|
|
var track = options['track'];
|
|
var tracks = player.textTracks();
|
|
|
|
// Modify options for parent MenuItem class's init.
|
|
options['label'] = track['label'] || track['language'] || 'Unknown';
|
|
options['selected'] = track['default'] || track['mode'] === 'showing';
|
|
|
|
_MenuItem.call(this, player, options);
|
|
|
|
this.track = track;
|
|
|
|
if (tracks) {
|
|
(function () {
|
|
var changeHandler = Fn.bind(_this, _this.handleTracksChange);
|
|
|
|
tracks.addEventListener('change', changeHandler);
|
|
_this.on('dispose', function () {
|
|
tracks.removeEventListener('change', changeHandler);
|
|
});
|
|
})();
|
|
}
|
|
|
|
// iOS7 doesn't dispatch change events to TextTrackLists when an
|
|
// associated track's mode changes. Without something like
|
|
// Object.observe() (also not present on iOS7), it's not
|
|
// possible to detect changes to the mode attribute and polyfill
|
|
// the change event. As a poor substitute, we manually dispatch
|
|
// change events whenever the controls modify the mode.
|
|
if (tracks && tracks.onchange === undefined) {
|
|
(function () {
|
|
var event = undefined;
|
|
|
|
_this.on(['tap', 'click'], function () {
|
|
if (typeof _globalWindow2['default'].Event !== 'object') {
|
|
// Android 2.3 throws an Illegal Constructor error for window.Event
|
|
try {
|
|
event = new _globalWindow2['default'].Event('change');
|
|
} catch (err) {}
|
|
}
|
|
|
|
if (!event) {
|
|
event = _globalDocument2['default'].createEvent('Event');
|
|
event.initEvent('change', true, true);
|
|
}
|
|
|
|
tracks.dispatchEvent(event);
|
|
});
|
|
})();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle click on text track
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
TextTrackMenuItem.prototype.handleClick = function handleClick(event) {
|
|
var kind = this.track['kind'];
|
|
var tracks = this.player_.textTracks();
|
|
|
|
_MenuItem.prototype.handleClick.call(this, event);
|
|
|
|
if (!tracks) return;
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
|
|
if (track['kind'] !== kind) {
|
|
continue;
|
|
}
|
|
|
|
if (track === this.track) {
|
|
track['mode'] = 'showing';
|
|
} else {
|
|
track['mode'] = 'disabled';
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle text track change
|
|
*
|
|
* @method handleTracksChange
|
|
*/
|
|
|
|
TextTrackMenuItem.prototype.handleTracksChange = function handleTracksChange(event) {
|
|
this.selected(this.track['mode'] === 'showing');
|
|
};
|
|
|
|
return TextTrackMenuItem;
|
|
})(_menuMenuItemJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('TextTrackMenuItem', TextTrackMenuItem);
|
|
exports['default'] = TextTrackMenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../menu/menu-item.js":110,"../../utils/fn.js":145,"global/document":1,"global/window":2}],94:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file current-time-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
/**
|
|
* Displays the current time
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class CurrentTimeDisplay
|
|
*/
|
|
|
|
var CurrentTimeDisplay = (function (_Component) {
|
|
_inherits(CurrentTimeDisplay, _Component);
|
|
|
|
function CurrentTimeDisplay(player, options) {
|
|
_classCallCheck(this, CurrentTimeDisplay);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
this.on(player, 'timeupdate', this.updateContent);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
CurrentTimeDisplay.prototype.createEl = function createEl() {
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-current-time vjs-time-control vjs-control'
|
|
});
|
|
|
|
this.contentEl_ = Dom.createEl('div', {
|
|
className: 'vjs-current-time-display',
|
|
// label the current time for screen reader users
|
|
innerHTML: '<span class="vjs-control-text">Current Time </span>' + '0:00'
|
|
}, {
|
|
// tell screen readers not to automatically read the time as it changes
|
|
'aria-live': 'off'
|
|
});
|
|
|
|
el.appendChild(this.contentEl_);
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Update current time display
|
|
*
|
|
* @method updateContent
|
|
*/
|
|
|
|
CurrentTimeDisplay.prototype.updateContent = function updateContent() {
|
|
// Allows for smooth scrubbing, when player can't keep up.
|
|
var time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
|
|
var localizedText = this.localize('Current Time');
|
|
var formattedTime = _utilsFormatTimeJs2['default'](time, this.player_.duration());
|
|
if (formattedTime !== this.formattedTime_) {
|
|
this.formattedTime_ = formattedTime;
|
|
this.contentEl_.innerHTML = '<span class="vjs-control-text">' + localizedText + '</span> ' + formattedTime;
|
|
}
|
|
};
|
|
|
|
return CurrentTimeDisplay;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('CurrentTimeDisplay', CurrentTimeDisplay);
|
|
exports['default'] = CurrentTimeDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/format-time.js":146}],95:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file duration-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
/**
|
|
* Displays the duration
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class DurationDisplay
|
|
*/
|
|
|
|
var DurationDisplay = (function (_Component) {
|
|
_inherits(DurationDisplay, _Component);
|
|
|
|
function DurationDisplay(player, options) {
|
|
_classCallCheck(this, DurationDisplay);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
// this might need to be changed to 'durationchange' instead of 'timeupdate' eventually,
|
|
// however the durationchange event fires before this.player_.duration() is set,
|
|
// so the value cannot be written out using this method.
|
|
// Once the order of durationchange and this.player_.duration() being set is figured out,
|
|
// this can be updated.
|
|
this.on(player, 'timeupdate', this.updateContent);
|
|
this.on(player, 'loadedmetadata', this.updateContent);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
DurationDisplay.prototype.createEl = function createEl() {
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-duration vjs-time-control vjs-control'
|
|
});
|
|
|
|
this.contentEl_ = Dom.createEl('div', {
|
|
className: 'vjs-duration-display',
|
|
// label the duration time for screen reader users
|
|
innerHTML: '<span class="vjs-control-text">' + this.localize('Duration Time') + '</span> 0:00'
|
|
}, {
|
|
// tell screen readers not to automatically read the time as it changes
|
|
'aria-live': 'off'
|
|
});
|
|
|
|
el.appendChild(this.contentEl_);
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Update duration time display
|
|
*
|
|
* @method updateContent
|
|
*/
|
|
|
|
DurationDisplay.prototype.updateContent = function updateContent() {
|
|
var duration = this.player_.duration();
|
|
if (duration && this.duration_ !== duration) {
|
|
this.duration_ = duration;
|
|
var localizedText = this.localize('Duration Time');
|
|
var formattedTime = _utilsFormatTimeJs2['default'](duration);
|
|
this.contentEl_.innerHTML = '<span class="vjs-control-text">' + localizedText + '</span> ' + formattedTime; // label the duration time for screen reader users
|
|
}
|
|
};
|
|
|
|
return DurationDisplay;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('DurationDisplay', DurationDisplay);
|
|
exports['default'] = DurationDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/format-time.js":146}],96:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file remaining-time-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFormatTimeJs = _dereq_('../../utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
/**
|
|
* Displays the time left in the video
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class RemainingTimeDisplay
|
|
*/
|
|
|
|
var RemainingTimeDisplay = (function (_Component) {
|
|
_inherits(RemainingTimeDisplay, _Component);
|
|
|
|
function RemainingTimeDisplay(player, options) {
|
|
_classCallCheck(this, RemainingTimeDisplay);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
this.on(player, 'timeupdate', this.updateContent);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
RemainingTimeDisplay.prototype.createEl = function createEl() {
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-remaining-time vjs-time-control vjs-control'
|
|
});
|
|
|
|
this.contentEl_ = Dom.createEl('div', {
|
|
className: 'vjs-remaining-time-display',
|
|
// label the remaining time for screen reader users
|
|
innerHTML: '<span class="vjs-control-text">' + this.localize('Remaining Time') + '</span> -0:00'
|
|
}, {
|
|
// tell screen readers not to automatically read the time as it changes
|
|
'aria-live': 'off'
|
|
});
|
|
|
|
el.appendChild(this.contentEl_);
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Update remaining time display
|
|
*
|
|
* @method updateContent
|
|
*/
|
|
|
|
RemainingTimeDisplay.prototype.updateContent = function updateContent() {
|
|
if (this.player_.duration()) {
|
|
var localizedText = this.localize('Remaining Time');
|
|
var formattedTime = _utilsFormatTimeJs2['default'](this.player_.remainingTime());
|
|
if (formattedTime !== this.formattedTime_) {
|
|
this.formattedTime_ = formattedTime;
|
|
this.contentEl_.innerHTML = '<span class="vjs-control-text">' + localizedText + '</span> -' + formattedTime;
|
|
}
|
|
}
|
|
|
|
// Allows for smooth scrubbing, when player can't keep up.
|
|
// var time = (this.player_.scrubbing()) ? this.player_.getCache().currentTime : this.player_.currentTime();
|
|
// this.contentEl_.innerHTML = vjs.formatTime(time, this.player_.duration());
|
|
};
|
|
|
|
return RemainingTimeDisplay;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('RemainingTimeDisplay', RemainingTimeDisplay);
|
|
exports['default'] = RemainingTimeDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../utils/dom.js":143,"../../utils/format-time.js":146}],97:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file time-divider.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* The separator between the current time and duration.
|
|
* Can be hidden if it's not needed in the design.
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class TimeDivider
|
|
*/
|
|
|
|
var TimeDivider = (function (_Component) {
|
|
_inherits(TimeDivider, _Component);
|
|
|
|
function TimeDivider() {
|
|
_classCallCheck(this, TimeDivider);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
TimeDivider.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-time-control vjs-time-divider',
|
|
innerHTML: '<div><span>/</span></div>'
|
|
});
|
|
};
|
|
|
|
return TimeDivider;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('TimeDivider', TimeDivider);
|
|
exports['default'] = TimeDivider;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67}],98:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file track-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _menuMenuButtonJs = _dereq_('../menu/menu-button.js');
|
|
|
|
var _menuMenuButtonJs2 = _interopRequireDefault(_menuMenuButtonJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
/**
|
|
* The base class for buttons that toggle specific text track types (e.g. subtitles)
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends MenuButton
|
|
* @class TrackButton
|
|
*/
|
|
|
|
var TrackButton = (function (_MenuButton) {
|
|
_inherits(TrackButton, _MenuButton);
|
|
|
|
function TrackButton(player, options) {
|
|
_classCallCheck(this, TrackButton);
|
|
|
|
var tracks = options.tracks;
|
|
|
|
_MenuButton.call(this, player, options);
|
|
|
|
if (this.items.length <= 1) {
|
|
this.hide();
|
|
}
|
|
|
|
if (!tracks) {
|
|
return;
|
|
}
|
|
|
|
var updateHandler = Fn.bind(this, this.update);
|
|
tracks.addEventListener('removetrack', updateHandler);
|
|
tracks.addEventListener('addtrack', updateHandler);
|
|
|
|
this.player_.on('dispose', function () {
|
|
tracks.removeEventListener('removetrack', updateHandler);
|
|
tracks.removeEventListener('addtrack', updateHandler);
|
|
});
|
|
}
|
|
|
|
return TrackButton;
|
|
})(_menuMenuButtonJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('TrackButton', TrackButton);
|
|
exports['default'] = TrackButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../menu/menu-button.js":109,"../utils/fn.js":145}],99:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file volume-bar.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _sliderSliderJs = _dereq_('../../slider/slider.js');
|
|
|
|
var _sliderSliderJs2 = _interopRequireDefault(_sliderSliderJs);
|
|
|
|
var _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('../../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
// Required children
|
|
|
|
var _volumeLevelJs = _dereq_('./volume-level.js');
|
|
|
|
var _volumeLevelJs2 = _interopRequireDefault(_volumeLevelJs);
|
|
|
|
/**
|
|
* The bar that contains the volume level and can be clicked on to adjust the level
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Slider
|
|
* @class VolumeBar
|
|
*/
|
|
|
|
var VolumeBar = (function (_Slider) {
|
|
_inherits(VolumeBar, _Slider);
|
|
|
|
function VolumeBar(player, options) {
|
|
_classCallCheck(this, VolumeBar);
|
|
|
|
_Slider.call(this, player, options);
|
|
this.on(player, 'volumechange', this.updateARIAAttributes);
|
|
player.ready(Fn.bind(this, this.updateARIAAttributes));
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
VolumeBar.prototype.createEl = function createEl() {
|
|
return _Slider.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-volume-bar vjs-slider-bar'
|
|
}, {
|
|
'aria-label': 'volume level'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Handle mouse move on volume bar
|
|
*
|
|
* @method handleMouseMove
|
|
*/
|
|
|
|
VolumeBar.prototype.handleMouseMove = function handleMouseMove(event) {
|
|
this.checkMuted();
|
|
this.player_.volume(this.calculateDistance(event));
|
|
};
|
|
|
|
VolumeBar.prototype.checkMuted = function checkMuted() {
|
|
if (this.player_.muted()) {
|
|
this.player_.muted(false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get percent of volume level
|
|
*
|
|
* @retun {Number} Volume level percent
|
|
* @method getPercent
|
|
*/
|
|
|
|
VolumeBar.prototype.getPercent = function getPercent() {
|
|
if (this.player_.muted()) {
|
|
return 0;
|
|
} else {
|
|
return this.player_.volume();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Increase volume level for keyboard users
|
|
*
|
|
* @method stepForward
|
|
*/
|
|
|
|
VolumeBar.prototype.stepForward = function stepForward() {
|
|
this.checkMuted();
|
|
this.player_.volume(this.player_.volume() + 0.1);
|
|
};
|
|
|
|
/**
|
|
* Decrease volume level for keyboard users
|
|
*
|
|
* @method stepBack
|
|
*/
|
|
|
|
VolumeBar.prototype.stepBack = function stepBack() {
|
|
this.checkMuted();
|
|
this.player_.volume(this.player_.volume() - 0.1);
|
|
};
|
|
|
|
/**
|
|
* Update ARIA accessibility attributes
|
|
*
|
|
* @method updateARIAAttributes
|
|
*/
|
|
|
|
VolumeBar.prototype.updateARIAAttributes = function updateARIAAttributes() {
|
|
// Current value of volume bar as a percentage
|
|
var volume = (this.player_.volume() * 100).toFixed(2);
|
|
this.el_.setAttribute('aria-valuenow', volume);
|
|
this.el_.setAttribute('aria-valuetext', volume + '%');
|
|
};
|
|
|
|
return VolumeBar;
|
|
})(_sliderSliderJs2['default']);
|
|
|
|
VolumeBar.prototype.options_ = {
|
|
children: ['volumeLevel'],
|
|
'barName': 'volumeLevel'
|
|
};
|
|
|
|
VolumeBar.prototype.playerEvent = 'volumechange';
|
|
|
|
_componentJs2['default'].registerComponent('VolumeBar', VolumeBar);
|
|
exports['default'] = VolumeBar;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"../../slider/slider.js":119,"../../utils/fn.js":145,"./volume-level.js":101}],100:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file volume-control.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
// Required children
|
|
|
|
var _volumeBarJs = _dereq_('./volume-bar.js');
|
|
|
|
var _volumeBarJs2 = _interopRequireDefault(_volumeBarJs);
|
|
|
|
/**
|
|
* The component for controlling the volume level
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class VolumeControl
|
|
*/
|
|
|
|
var VolumeControl = (function (_Component) {
|
|
_inherits(VolumeControl, _Component);
|
|
|
|
function VolumeControl(player, options) {
|
|
_classCallCheck(this, VolumeControl);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
// hide volume controls when they're not supported by the current tech
|
|
if (player.tech_ && player.tech_['featuresVolumeControl'] === false) {
|
|
this.addClass('vjs-hidden');
|
|
}
|
|
this.on(player, 'loadstart', function () {
|
|
if (player.tech_['featuresVolumeControl'] === false) {
|
|
this.addClass('vjs-hidden');
|
|
} else {
|
|
this.removeClass('vjs-hidden');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
VolumeControl.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-volume-control vjs-control'
|
|
});
|
|
};
|
|
|
|
return VolumeControl;
|
|
})(_componentJs2['default']);
|
|
|
|
VolumeControl.prototype.options_ = {
|
|
children: ['volumeBar']
|
|
};
|
|
|
|
_componentJs2['default'].registerComponent('VolumeControl', VolumeControl);
|
|
exports['default'] = VolumeControl;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67,"./volume-bar.js":99}],101:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file volume-level.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
/**
|
|
* Shows volume level
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class VolumeLevel
|
|
*/
|
|
|
|
var VolumeLevel = (function (_Component) {
|
|
_inherits(VolumeLevel, _Component);
|
|
|
|
function VolumeLevel() {
|
|
_classCallCheck(this, VolumeLevel);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
VolumeLevel.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-volume-level',
|
|
innerHTML: '<span class="vjs-control-text"></span>'
|
|
});
|
|
};
|
|
|
|
return VolumeLevel;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('VolumeLevel', VolumeLevel);
|
|
exports['default'] = VolumeLevel;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../component.js":67}],102:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file volume-menu-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
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 _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _popupPopupJs = _dereq_('../popup/popup.js');
|
|
|
|
var _popupPopupJs2 = _interopRequireDefault(_popupPopupJs);
|
|
|
|
var _popupPopupButtonJs = _dereq_('../popup/popup-button.js');
|
|
|
|
var _popupPopupButtonJs2 = _interopRequireDefault(_popupPopupButtonJs);
|
|
|
|
var _muteToggleJs = _dereq_('./mute-toggle.js');
|
|
|
|
var _muteToggleJs2 = _interopRequireDefault(_muteToggleJs);
|
|
|
|
var _volumeControlVolumeBarJs = _dereq_('./volume-control/volume-bar.js');
|
|
|
|
var _volumeControlVolumeBarJs2 = _interopRequireDefault(_volumeControlVolumeBarJs);
|
|
|
|
/**
|
|
* Button for volume popup
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends PopupButton
|
|
* @class VolumeMenuButton
|
|
*/
|
|
|
|
var VolumeMenuButton = (function (_PopupButton) {
|
|
_inherits(VolumeMenuButton, _PopupButton);
|
|
|
|
function VolumeMenuButton(player) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
_classCallCheck(this, VolumeMenuButton);
|
|
|
|
// Default to inline
|
|
if (options.inline === undefined) {
|
|
options.inline = true;
|
|
}
|
|
|
|
// If the vertical option isn't passed at all, default to true.
|
|
if (options.vertical === undefined) {
|
|
// If an inline volumeMenuButton is used, we should default to using
|
|
// a horizontal slider for obvious reasons.
|
|
if (options.inline) {
|
|
options.vertical = false;
|
|
} else {
|
|
options.vertical = true;
|
|
}
|
|
}
|
|
|
|
// The vertical option needs to be set on the volumeBar as well,
|
|
// since that will need to be passed along to the VolumeBar constructor
|
|
options.volumeBar = options.volumeBar || {};
|
|
options.volumeBar.vertical = !!options.vertical;
|
|
|
|
_PopupButton.call(this, player, options);
|
|
|
|
// Same listeners as MuteToggle
|
|
this.on(player, 'volumechange', this.volumeUpdate);
|
|
this.on(player, 'loadstart', this.volumeUpdate);
|
|
|
|
// hide mute toggle if the current tech doesn't support volume control
|
|
function updateVisibility() {
|
|
if (player.tech_ && player.tech_['featuresVolumeControl'] === false) {
|
|
this.addClass('vjs-hidden');
|
|
} else {
|
|
this.removeClass('vjs-hidden');
|
|
}
|
|
}
|
|
|
|
updateVisibility.call(this);
|
|
this.on(player, 'loadstart', updateVisibility);
|
|
|
|
this.on(this.volumeBar, ['slideractive', 'focus'], function () {
|
|
this.addClass('vjs-slider-active');
|
|
});
|
|
|
|
this.on(this.volumeBar, ['sliderinactive', 'blur'], function () {
|
|
this.removeClass('vjs-slider-active');
|
|
});
|
|
|
|
this.on(this.volumeBar, ['focus'], function () {
|
|
this.addClass('vjs-lock-showing');
|
|
});
|
|
|
|
this.on(this.volumeBar, ['blur'], function () {
|
|
this.removeClass('vjs-lock-showing');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
VolumeMenuButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
var orientationClass = '';
|
|
if (!!this.options_.vertical) {
|
|
orientationClass = 'vjs-volume-menu-button-vertical';
|
|
} else {
|
|
orientationClass = 'vjs-volume-menu-button-horizontal';
|
|
}
|
|
|
|
return 'vjs-volume-menu-button ' + _PopupButton.prototype.buildCSSClass.call(this) + ' ' + orientationClass;
|
|
};
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {Popup} The volume popup button
|
|
* @method createPopup
|
|
*/
|
|
|
|
VolumeMenuButton.prototype.createPopup = function createPopup() {
|
|
var popup = new _popupPopupJs2['default'](this.player_, {
|
|
contentElType: 'div'
|
|
});
|
|
|
|
var vb = new _volumeControlVolumeBarJs2['default'](this.player_, this.options_.volumeBar);
|
|
|
|
popup.addChild(vb);
|
|
|
|
this.menuContent = popup;
|
|
this.volumeBar = vb;
|
|
|
|
this.attachVolumeBarEvents();
|
|
|
|
return popup;
|
|
};
|
|
|
|
/**
|
|
* Handle click on volume popup and calls super
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
VolumeMenuButton.prototype.handleClick = function handleClick() {
|
|
_muteToggleJs2['default'].prototype.handleClick.call(this);
|
|
_PopupButton.prototype.handleClick.call(this);
|
|
};
|
|
|
|
VolumeMenuButton.prototype.attachVolumeBarEvents = function attachVolumeBarEvents() {
|
|
this.menuContent.on(['mousedown', 'touchdown'], Fn.bind(this, this.handleMouseDown));
|
|
};
|
|
|
|
VolumeMenuButton.prototype.handleMouseDown = function handleMouseDown(event) {
|
|
this.on(['mousemove', 'touchmove'], Fn.bind(this.volumeBar, this.volumeBar.handleMouseMove));
|
|
this.on(this.el_.ownerDocument, ['mouseup', 'touchend'], this.handleMouseUp);
|
|
};
|
|
|
|
VolumeMenuButton.prototype.handleMouseUp = function handleMouseUp(event) {
|
|
this.off(['mousemove', 'touchmove'], Fn.bind(this.volumeBar, this.volumeBar.handleMouseMove));
|
|
};
|
|
|
|
return VolumeMenuButton;
|
|
})(_popupPopupButtonJs2['default']);
|
|
|
|
VolumeMenuButton.prototype.volumeUpdate = _muteToggleJs2['default'].prototype.update;
|
|
VolumeMenuButton.prototype.controlText_ = 'Mute';
|
|
|
|
_componentJs2['default'].registerComponent('VolumeMenuButton', VolumeMenuButton);
|
|
exports['default'] = VolumeMenuButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../popup/popup-button.js":115,"../popup/popup.js":116,"../utils/fn.js":145,"./mute-toggle.js":73,"./volume-control/volume-bar.js":99}],103:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file error-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _modalDialog = _dereq_('./modal-dialog');
|
|
|
|
var _modalDialog2 = _interopRequireDefault(_modalDialog);
|
|
|
|
var _utilsDom = _dereq_('./utils/dom');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDom);
|
|
|
|
var _utilsMergeOptions = _dereq_('./utils/merge-options');
|
|
|
|
var _utilsMergeOptions2 = _interopRequireDefault(_utilsMergeOptions);
|
|
|
|
/**
|
|
* Display that an error has occurred making the video unplayable.
|
|
*
|
|
* @extends ModalDialog
|
|
* @class ErrorDisplay
|
|
*/
|
|
|
|
var ErrorDisplay = (function (_ModalDialog) {
|
|
_inherits(ErrorDisplay, _ModalDialog);
|
|
|
|
/**
|
|
* Constructor for error display modal.
|
|
*
|
|
* @param {Player} player
|
|
* @param {Object} [options]
|
|
*/
|
|
|
|
function ErrorDisplay(player, options) {
|
|
_classCallCheck(this, ErrorDisplay);
|
|
|
|
_ModalDialog.call(this, player, options);
|
|
this.on(player, 'error', this.open);
|
|
}
|
|
|
|
/**
|
|
* Include the old class for backward-compatibility.
|
|
*
|
|
* This can be removed in 6.0.
|
|
*
|
|
* @method buildCSSClass
|
|
* @deprecated
|
|
* @return {String}
|
|
*/
|
|
|
|
ErrorDisplay.prototype.buildCSSClass = function buildCSSClass() {
|
|
return 'vjs-error-display ' + _ModalDialog.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Generates the modal content based on the player error.
|
|
*
|
|
* @return {String|Null}
|
|
*/
|
|
|
|
ErrorDisplay.prototype.content = function content() {
|
|
var error = this.player().error();
|
|
return error ? this.localize(error.message) : '';
|
|
};
|
|
|
|
return ErrorDisplay;
|
|
})(_modalDialog2['default']);
|
|
|
|
ErrorDisplay.prototype.options_ = _utilsMergeOptions2['default'](_modalDialog2['default'].prototype.options_, {
|
|
fillAlways: true,
|
|
temporary: false,
|
|
uncloseable: true
|
|
});
|
|
|
|
_component2['default'].registerComponent('ErrorDisplay', ErrorDisplay);
|
|
exports['default'] = ErrorDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./component":67,"./modal-dialog":112,"./utils/dom":143,"./utils/merge-options":149}],104:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file event-target.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var EventTarget = function EventTarget() {};
|
|
|
|
EventTarget.prototype.allowedEvents_ = {};
|
|
|
|
EventTarget.prototype.on = function (type, fn) {
|
|
// Remove the addEventListener alias before calling Events.on
|
|
// so we don't get into an infinite type loop
|
|
var ael = this.addEventListener;
|
|
this.addEventListener = function () {};
|
|
Events.on(this, type, fn);
|
|
this.addEventListener = ael;
|
|
};
|
|
EventTarget.prototype.addEventListener = EventTarget.prototype.on;
|
|
|
|
EventTarget.prototype.off = function (type, fn) {
|
|
Events.off(this, type, fn);
|
|
};
|
|
EventTarget.prototype.removeEventListener = EventTarget.prototype.off;
|
|
|
|
EventTarget.prototype.one = function (type, fn) {
|
|
// Remove the addEventListener alias before calling Events.on
|
|
// so we don't get into an infinite type loop
|
|
var ael = this.addEventListener;
|
|
this.addEventListener = function () {};
|
|
Events.one(this, type, fn);
|
|
this.addEventListener = ael;
|
|
};
|
|
|
|
EventTarget.prototype.trigger = function (event) {
|
|
var type = event.type || event;
|
|
|
|
if (typeof event === 'string') {
|
|
event = {
|
|
type: type
|
|
};
|
|
}
|
|
event = Events.fixEvent(event);
|
|
|
|
if (this.allowedEvents_[type] && this['on' + type]) {
|
|
this['on' + type](event);
|
|
}
|
|
|
|
Events.trigger(this, event);
|
|
};
|
|
// The standard DOM EventTarget.dispatchEvent() is aliased to trigger()
|
|
EventTarget.prototype.dispatchEvent = EventTarget.prototype.trigger;
|
|
|
|
exports['default'] = EventTarget;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./utils/events.js":144}],105:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _utilsLog = _dereq_('./utils/log');
|
|
|
|
var _utilsLog2 = _interopRequireDefault(_utilsLog);
|
|
|
|
/*
|
|
* @file extend.js
|
|
*
|
|
* A combination of node inherits and babel's inherits (after transpile).
|
|
* Both work the same but node adds `super_` to the subClass
|
|
* and Bable adds the superClass as __proto__. Both seem useful.
|
|
*/
|
|
var _inherits = 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) {
|
|
// node
|
|
subClass.super_ = superClass;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Function for subclassing using the same inheritance that
|
|
* videojs uses internally
|
|
* ```js
|
|
* var Button = videojs.getComponent('Button');
|
|
* ```
|
|
* ```js
|
|
* var MyButton = videojs.extend(Button, {
|
|
* constructor: function(player, options) {
|
|
* Button.call(this, player, options);
|
|
* },
|
|
* onClick: function() {
|
|
* // doSomething
|
|
* }
|
|
* });
|
|
* ```
|
|
*/
|
|
var extendFn = function extendFn(superClass) {
|
|
var subClassMethods = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
var subClass = function subClass() {
|
|
superClass.apply(this, arguments);
|
|
};
|
|
var methods = {};
|
|
|
|
if (typeof subClassMethods === 'object') {
|
|
if (typeof subClassMethods.init === 'function') {
|
|
_utilsLog2['default'].warn('Constructor logic via init() is deprecated; please use constructor() instead.');
|
|
subClassMethods.constructor = subClassMethods.init;
|
|
}
|
|
if (subClassMethods.constructor !== Object.prototype.constructor) {
|
|
subClass = subClassMethods.constructor;
|
|
}
|
|
methods = subClassMethods;
|
|
} else if (typeof subClassMethods === 'function') {
|
|
subClass = subClassMethods;
|
|
}
|
|
|
|
_inherits(subClass, superClass);
|
|
|
|
// Extend subObj's prototype with functions and other properties from props
|
|
for (var name in methods) {
|
|
if (methods.hasOwnProperty(name)) {
|
|
subClass.prototype[name] = methods[name];
|
|
}
|
|
}
|
|
|
|
return subClass;
|
|
};
|
|
|
|
exports['default'] = extendFn;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./utils/log":148}],106:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file fullscreen-api.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/*
|
|
* Store the browser-specific methods for the fullscreen API
|
|
* @type {Object|undefined}
|
|
* @private
|
|
*/
|
|
var FullscreenApi = {};
|
|
|
|
// browser API methods
|
|
// map approach from Screenful.js - https://github.com/sindresorhus/screenfull.js
|
|
var apiMap = [
|
|
// Spec: https://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
|
|
['requestFullscreen', 'exitFullscreen', 'fullscreenElement', 'fullscreenEnabled', 'fullscreenchange', 'fullscreenerror'],
|
|
// WebKit
|
|
['webkitRequestFullscreen', 'webkitExitFullscreen', 'webkitFullscreenElement', 'webkitFullscreenEnabled', 'webkitfullscreenchange', 'webkitfullscreenerror'],
|
|
// Old WebKit (Safari 5.1)
|
|
['webkitRequestFullScreen', 'webkitCancelFullScreen', 'webkitCurrentFullScreenElement', 'webkitCancelFullScreen', 'webkitfullscreenchange', 'webkitfullscreenerror'],
|
|
// Mozilla
|
|
['mozRequestFullScreen', 'mozCancelFullScreen', 'mozFullScreenElement', 'mozFullScreenEnabled', 'mozfullscreenchange', 'mozfullscreenerror'],
|
|
// Microsoft
|
|
['msRequestFullscreen', 'msExitFullscreen', 'msFullscreenElement', 'msFullscreenEnabled', 'MSFullscreenChange', 'MSFullscreenError']];
|
|
|
|
var specApi = apiMap[0];
|
|
var browserApi = undefined;
|
|
|
|
// determine the supported set of functions
|
|
for (var i = 0; i < apiMap.length; i++) {
|
|
// check for exitFullscreen function
|
|
if (apiMap[i][1] in _globalDocument2['default']) {
|
|
browserApi = apiMap[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// map the browser API names to the spec API names
|
|
if (browserApi) {
|
|
for (var i = 0; i < browserApi.length; i++) {
|
|
FullscreenApi[specApi[i]] = browserApi[i];
|
|
}
|
|
}
|
|
|
|
exports['default'] = FullscreenApi;
|
|
module.exports = exports['default'];
|
|
|
|
},{"global/document":1}],107:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file loading-spinner.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
/* Loading Spinner
|
|
================================================================================ */
|
|
/**
|
|
* Loading spinner for waiting events
|
|
*
|
|
* @extends Component
|
|
* @class LoadingSpinner
|
|
*/
|
|
|
|
var LoadingSpinner = (function (_Component) {
|
|
_inherits(LoadingSpinner, _Component);
|
|
|
|
function LoadingSpinner() {
|
|
_classCallCheck(this, LoadingSpinner);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @method createEl
|
|
*/
|
|
|
|
LoadingSpinner.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-loading-spinner',
|
|
dir: 'ltr'
|
|
});
|
|
};
|
|
|
|
return LoadingSpinner;
|
|
})(_component2['default']);
|
|
|
|
_component2['default'].registerComponent('LoadingSpinner', LoadingSpinner);
|
|
exports['default'] = LoadingSpinner;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./component":67}],108:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file media-error.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/*
|
|
* Custom MediaError to mimic the HTML5 MediaError
|
|
*
|
|
* @param {Number} code The media error code
|
|
*/
|
|
var MediaError = function MediaError(code) {
|
|
if (typeof code === 'number') {
|
|
this.code = code;
|
|
} else if (typeof code === 'string') {
|
|
// default code is zero, so this is a custom error
|
|
this.message = code;
|
|
} else if (typeof code === 'object') {
|
|
// object
|
|
_objectAssign2['default'](this, code);
|
|
}
|
|
|
|
if (!this.message) {
|
|
this.message = MediaError.defaultMessages[this.code] || '';
|
|
}
|
|
};
|
|
|
|
/*
|
|
* The error code that refers two one of the defined
|
|
* MediaError types
|
|
*
|
|
* @type {Number}
|
|
*/
|
|
MediaError.prototype.code = 0;
|
|
|
|
/*
|
|
* An optional message to be shown with the error.
|
|
* Message is not part of the HTML5 video spec
|
|
* but allows for more informative custom errors.
|
|
*
|
|
* @type {String}
|
|
*/
|
|
MediaError.prototype.message = '';
|
|
|
|
/*
|
|
* An optional status code that can be set by plugins
|
|
* to allow even more detail about the error.
|
|
* For example the HLS plugin might provide the specific
|
|
* HTTP status code that was returned when the error
|
|
* occurred, then allowing a custom error overlay
|
|
* to display more information.
|
|
*
|
|
* @type {Array}
|
|
*/
|
|
MediaError.prototype.status = null;
|
|
|
|
MediaError.errorTypes = ['MEDIA_ERR_CUSTOM', // = 0
|
|
'MEDIA_ERR_ABORTED', // = 1
|
|
'MEDIA_ERR_NETWORK', // = 2
|
|
'MEDIA_ERR_DECODE', // = 3
|
|
'MEDIA_ERR_SRC_NOT_SUPPORTED', // = 4
|
|
'MEDIA_ERR_ENCRYPTED' // = 5
|
|
];
|
|
|
|
MediaError.defaultMessages = {
|
|
1: 'You aborted the media playback',
|
|
2: 'A network error caused the media download to fail part-way.',
|
|
3: 'The media playback was aborted due to a corruption problem or because the media used features your browser did not support.',
|
|
4: 'The media could not be loaded, either because the server or network failed or because the format is not supported.',
|
|
5: 'The media is encrypted and we do not have the keys to decrypt it.'
|
|
};
|
|
|
|
// Add types as properties on MediaError
|
|
// e.g. MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
|
|
for (var errNum = 0; errNum < MediaError.errorTypes.length; errNum++) {
|
|
MediaError[MediaError.errorTypes[errNum]] = errNum;
|
|
// values should be accessible on both the class and instance
|
|
MediaError.prototype[MediaError.errorTypes[errNum]] = errNum;
|
|
}
|
|
|
|
exports['default'] = MediaError;
|
|
module.exports = exports['default'];
|
|
|
|
},{"object.assign":45}],109:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file menu-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _clickableComponentJs = _dereq_('../clickable-component.js');
|
|
|
|
var _clickableComponentJs2 = _interopRequireDefault(_clickableComponentJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _menuJs = _dereq_('./menu.js');
|
|
|
|
var _menuJs2 = _interopRequireDefault(_menuJs);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('../utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
/**
|
|
* A button class with a popup menu
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Button
|
|
* @class MenuButton
|
|
*/
|
|
|
|
var MenuButton = (function (_ClickableComponent) {
|
|
_inherits(MenuButton, _ClickableComponent);
|
|
|
|
function MenuButton(player) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
_classCallCheck(this, MenuButton);
|
|
|
|
_ClickableComponent.call(this, player, options);
|
|
|
|
this.update();
|
|
|
|
this.enabled_ = true;
|
|
|
|
this.el_.setAttribute('aria-haspopup', 'true');
|
|
this.el_.setAttribute('role', 'menuitem');
|
|
this.on('keydown', this.handleSubmenuKeyPress);
|
|
}
|
|
|
|
/**
|
|
* Update menu
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
MenuButton.prototype.update = function update() {
|
|
var menu = this.createMenu();
|
|
|
|
if (this.menu) {
|
|
this.removeChild(this.menu);
|
|
}
|
|
|
|
this.menu = menu;
|
|
this.addChild(menu);
|
|
|
|
/**
|
|
* Track the state of the menu button
|
|
*
|
|
* @type {Boolean}
|
|
* @private
|
|
*/
|
|
this.buttonPressed_ = false;
|
|
this.el_.setAttribute('aria-expanded', 'false');
|
|
|
|
if (this.items && this.items.length === 0) {
|
|
this.hide();
|
|
} else if (this.items && this.items.length > 1) {
|
|
this.show();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create menu
|
|
*
|
|
* @return {Menu} The constructed menu
|
|
* @method createMenu
|
|
*/
|
|
|
|
MenuButton.prototype.createMenu = function createMenu() {
|
|
var menu = new _menuJs2['default'](this.player_);
|
|
|
|
// Add a title list item to the top
|
|
if (this.options_.title) {
|
|
var title = Dom.createEl('li', {
|
|
className: 'vjs-menu-title',
|
|
innerHTML: _utilsToTitleCaseJs2['default'](this.options_.title),
|
|
tabIndex: -1
|
|
});
|
|
menu.children_.unshift(title);
|
|
Dom.insertElFirst(title, menu.contentEl());
|
|
}
|
|
|
|
this.items = this['createItems']();
|
|
|
|
if (this.items) {
|
|
// Add menu items to the menu
|
|
for (var i = 0; i < this.items.length; i++) {
|
|
menu.addItem(this.items[i]);
|
|
}
|
|
}
|
|
|
|
return menu;
|
|
};
|
|
|
|
/**
|
|
* Create the list of menu items. Specific to each subclass.
|
|
*
|
|
* @method createItems
|
|
*/
|
|
|
|
MenuButton.prototype.createItems = function createItems() {};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
MenuButton.prototype.createEl = function createEl() {
|
|
return _ClickableComponent.prototype.createEl.call(this, 'div', {
|
|
className: this.buildCSSClass()
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
MenuButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
var menuButtonClass = 'vjs-menu-button';
|
|
|
|
// If the inline option is passed, we want to use different styles altogether.
|
|
if (this.options_.inline === true) {
|
|
menuButtonClass += '-inline';
|
|
} else {
|
|
menuButtonClass += '-popup';
|
|
}
|
|
|
|
return 'vjs-menu-button ' + menuButtonClass + ' ' + _ClickableComponent.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* When you click the button it adds focus, which
|
|
* will show the menu indefinitely.
|
|
* So we'll remove focus when the mouse leaves the button.
|
|
* Focus is needed for tab navigation.
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
MenuButton.prototype.handleClick = function handleClick() {
|
|
this.one('mouseout', Fn.bind(this, function () {
|
|
this.menu.unlockShowing();
|
|
this.el_.blur();
|
|
}));
|
|
if (this.buttonPressed_) {
|
|
this.unpressButton();
|
|
} else {
|
|
this.pressButton();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle key press on menu
|
|
*
|
|
* @param {Object} event Key press event
|
|
* @method handleKeyPress
|
|
*/
|
|
|
|
MenuButton.prototype.handleKeyPress = function handleKeyPress(event) {
|
|
|
|
// Escape (27) key or Tab (9) key unpress the 'button'
|
|
if (event.which === 27 || event.which === 9) {
|
|
if (this.buttonPressed_) {
|
|
this.unpressButton();
|
|
}
|
|
// Don't preventDefault for Tab key - we still want to lose focus
|
|
if (event.which !== 9) {
|
|
event.preventDefault();
|
|
}
|
|
// Up (38) key or Down (40) key press the 'button'
|
|
} else if (event.which === 38 || event.which === 40) {
|
|
if (!this.buttonPressed_) {
|
|
this.pressButton();
|
|
event.preventDefault();
|
|
}
|
|
} else {
|
|
_ClickableComponent.prototype.handleKeyPress.call(this, event);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle key press on submenu
|
|
*
|
|
* @param {Object} event Key press event
|
|
* @method handleSubmenuKeyPress
|
|
*/
|
|
|
|
MenuButton.prototype.handleSubmenuKeyPress = function handleSubmenuKeyPress(event) {
|
|
|
|
// Escape (27) key or Tab (9) key unpress the 'button'
|
|
if (event.which === 27 || event.which === 9) {
|
|
if (this.buttonPressed_) {
|
|
this.unpressButton();
|
|
}
|
|
// Don't preventDefault for Tab key - we still want to lose focus
|
|
if (event.which !== 9) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Makes changes based on button pressed
|
|
*
|
|
* @method pressButton
|
|
*/
|
|
|
|
MenuButton.prototype.pressButton = function pressButton() {
|
|
if (this.enabled_) {
|
|
this.buttonPressed_ = true;
|
|
this.menu.lockShowing();
|
|
this.el_.setAttribute('aria-expanded', 'true');
|
|
this.menu.focus(); // set the focus into the submenu
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Makes changes based on button unpressed
|
|
*
|
|
* @method unpressButton
|
|
*/
|
|
|
|
MenuButton.prototype.unpressButton = function unpressButton() {
|
|
if (this.enabled_) {
|
|
this.buttonPressed_ = false;
|
|
this.menu.unlockShowing();
|
|
this.el_.setAttribute('aria-expanded', 'false');
|
|
this.el_.focus(); // Set focus back to this menu button
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Disable the menu button
|
|
*
|
|
* @return {Component}
|
|
* @method disable
|
|
*/
|
|
|
|
MenuButton.prototype.disable = function disable() {
|
|
// Unpress, but don't force focus on this button
|
|
this.buttonPressed_ = false;
|
|
this.menu.unlockShowing();
|
|
this.el_.setAttribute('aria-expanded', 'false');
|
|
|
|
this.enabled_ = false;
|
|
|
|
return _ClickableComponent.prototype.disable.call(this);
|
|
};
|
|
|
|
/**
|
|
* Enable the menu button
|
|
*
|
|
* @return {Component}
|
|
* @method disable
|
|
*/
|
|
|
|
MenuButton.prototype.enable = function enable() {
|
|
this.enabled_ = true;
|
|
|
|
return _ClickableComponent.prototype.enable.call(this);
|
|
};
|
|
|
|
return MenuButton;
|
|
})(_clickableComponentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('MenuButton', MenuButton);
|
|
exports['default'] = MenuButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../clickable-component.js":65,"../component.js":67,"../utils/dom.js":143,"../utils/fn.js":145,"../utils/to-title-case.js":152,"./menu.js":111}],110:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file menu-item.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _clickableComponentJs = _dereq_('../clickable-component.js');
|
|
|
|
var _clickableComponentJs2 = _interopRequireDefault(_clickableComponentJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/**
|
|
* The component for a menu item. `<li>`
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Button
|
|
* @class MenuItem
|
|
*/
|
|
|
|
var MenuItem = (function (_ClickableComponent) {
|
|
_inherits(MenuItem, _ClickableComponent);
|
|
|
|
function MenuItem(player, options) {
|
|
_classCallCheck(this, MenuItem);
|
|
|
|
_ClickableComponent.call(this, player, options);
|
|
|
|
this.selectable = options['selectable'];
|
|
|
|
this.selected(options['selected']);
|
|
|
|
if (this.selectable) {
|
|
// TODO: May need to be either menuitemcheckbox or menuitemradio,
|
|
// and may need logical grouping of menu items.
|
|
this.el_.setAttribute('role', 'menuitemcheckbox');
|
|
} else {
|
|
this.el_.setAttribute('role', 'menuitem');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @param {String=} type Desc
|
|
* @param {Object=} props Desc
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
MenuItem.prototype.createEl = function createEl(type, props, attrs) {
|
|
return _ClickableComponent.prototype.createEl.call(this, 'li', _objectAssign2['default']({
|
|
className: 'vjs-menu-item',
|
|
innerHTML: this.localize(this.options_['label']),
|
|
tabIndex: -1
|
|
}, props), attrs);
|
|
};
|
|
|
|
/**
|
|
* Handle a click on the menu item, and set it to selected
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
MenuItem.prototype.handleClick = function handleClick() {
|
|
this.selected(true);
|
|
};
|
|
|
|
/**
|
|
* Set this menu item as selected or not
|
|
*
|
|
* @param {Boolean} selected
|
|
* @method selected
|
|
*/
|
|
|
|
MenuItem.prototype.selected = function selected(_selected) {
|
|
if (this.selectable) {
|
|
if (_selected) {
|
|
this.addClass('vjs-selected');
|
|
this.el_.setAttribute('aria-checked', 'true');
|
|
// aria-checked isn't fully supported by browsers/screen readers,
|
|
// so indicate selected state to screen reader in the control text.
|
|
this.controlText(', selected');
|
|
} else {
|
|
this.removeClass('vjs-selected');
|
|
this.el_.setAttribute('aria-checked', 'false');
|
|
// Indicate un-selected state to screen reader
|
|
// Note that a space clears out the selected state text
|
|
this.controlText(' ');
|
|
}
|
|
}
|
|
};
|
|
|
|
return MenuItem;
|
|
})(_clickableComponentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('MenuItem', MenuItem);
|
|
exports['default'] = MenuItem;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../clickable-component.js":65,"../component.js":67,"object.assign":45}],111:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file menu.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsEventsJs = _dereq_('../utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
/**
|
|
* The Menu component is used to build pop up menus, including subtitle and
|
|
* captions selection menus.
|
|
*
|
|
* @extends Component
|
|
* @class Menu
|
|
*/
|
|
|
|
var Menu = (function (_Component) {
|
|
_inherits(Menu, _Component);
|
|
|
|
function Menu(player, options) {
|
|
_classCallCheck(this, Menu);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
this.focusedChild_ = -1;
|
|
|
|
this.on('keydown', this.handleKeyPress);
|
|
}
|
|
|
|
/**
|
|
* Add a menu item to the menu
|
|
*
|
|
* @param {Object|String} component Component or component type to add
|
|
* @method addItem
|
|
*/
|
|
|
|
Menu.prototype.addItem = function addItem(component) {
|
|
this.addChild(component);
|
|
component.on('click', Fn.bind(this, function () {
|
|
this.unlockShowing();
|
|
//TODO: Need to set keyboard focus back to the menuButton
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Menu.prototype.createEl = function createEl() {
|
|
var contentElType = this.options_.contentElType || 'ul';
|
|
this.contentEl_ = Dom.createEl(contentElType, {
|
|
className: 'vjs-menu-content'
|
|
});
|
|
this.contentEl_.setAttribute('role', 'menu');
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
append: this.contentEl_,
|
|
className: 'vjs-menu'
|
|
});
|
|
el.setAttribute('role', 'presentation');
|
|
el.appendChild(this.contentEl_);
|
|
|
|
// Prevent clicks from bubbling up. Needed for Menu Buttons,
|
|
// where a click on the parent is significant
|
|
Events.on(el, 'click', function (event) {
|
|
event.preventDefault();
|
|
event.stopImmediatePropagation();
|
|
});
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Handle key press for menu
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method handleKeyPress
|
|
*/
|
|
|
|
Menu.prototype.handleKeyPress = function handleKeyPress(event) {
|
|
if (event.which === 37 || event.which === 40) {
|
|
// Left and Down Arrows
|
|
event.preventDefault();
|
|
this.stepForward();
|
|
} else if (event.which === 38 || event.which === 39) {
|
|
// Up and Right Arrows
|
|
event.preventDefault();
|
|
this.stepBack();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Move to next (lower) menu item for keyboard users
|
|
*
|
|
* @method stepForward
|
|
*/
|
|
|
|
Menu.prototype.stepForward = function stepForward() {
|
|
var stepChild = 0;
|
|
|
|
if (this.focusedChild_ !== undefined) {
|
|
stepChild = this.focusedChild_ + 1;
|
|
}
|
|
this.focus(stepChild);
|
|
};
|
|
|
|
/**
|
|
* Move to previous (higher) menu item for keyboard users
|
|
*
|
|
* @method stepBack
|
|
*/
|
|
|
|
Menu.prototype.stepBack = function stepBack() {
|
|
var stepChild = 0;
|
|
|
|
if (this.focusedChild_ !== undefined) {
|
|
stepChild = this.focusedChild_ - 1;
|
|
}
|
|
this.focus(stepChild);
|
|
};
|
|
|
|
/**
|
|
* Set focus on a menu item in the menu
|
|
*
|
|
* @param {Object|String} item Index of child item set focus on
|
|
* @method focus
|
|
*/
|
|
|
|
Menu.prototype.focus = function focus() {
|
|
var item = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];
|
|
|
|
var children = this.children().slice();
|
|
var haveTitle = children.length && children[0].className && /vjs-menu-title/.test(children[0].className);
|
|
|
|
if (haveTitle) {
|
|
children.shift();
|
|
}
|
|
|
|
if (children.length > 0) {
|
|
if (item < 0) {
|
|
item = 0;
|
|
} else if (item >= children.length) {
|
|
item = children.length - 1;
|
|
}
|
|
|
|
this.focusedChild_ = item;
|
|
|
|
children[item].el_.focus();
|
|
}
|
|
};
|
|
|
|
return Menu;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('Menu', Menu);
|
|
exports['default'] = Menu;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../utils/dom.js":143,"../utils/events.js":144,"../utils/fn.js":145}],112:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file modal-dialog.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
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 _utilsDom = _dereq_('./utils/dom');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDom);
|
|
|
|
var _utilsFn = _dereq_('./utils/fn');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFn);
|
|
|
|
var _utilsLog = _dereq_('./utils/log');
|
|
|
|
var _utilsLog2 = _interopRequireDefault(_utilsLog);
|
|
|
|
var _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _closeButton = _dereq_('./close-button');
|
|
|
|
var _closeButton2 = _interopRequireDefault(_closeButton);
|
|
|
|
var MODAL_CLASS_NAME = 'vjs-modal-dialog';
|
|
var ESC = 27;
|
|
|
|
/**
|
|
* The `ModalDialog` displays over the video and its controls, which blocks
|
|
* interaction with the player until it is closed.
|
|
*
|
|
* Modal dialogs include a "Close" button and will close when that button
|
|
* is activated - or when ESC is pressed anywhere.
|
|
*
|
|
* @extends Component
|
|
* @class ModalDialog
|
|
*/
|
|
|
|
var ModalDialog = (function (_Component) {
|
|
_inherits(ModalDialog, _Component);
|
|
|
|
/**
|
|
* Constructor for modals.
|
|
*
|
|
* @param {Player} player
|
|
* @param {Object} [options]
|
|
* @param {Mixed} [options.content=undefined]
|
|
* Provide customized content for this modal.
|
|
*
|
|
* @param {String} [options.description]
|
|
* A text description for the modal, primarily for accessibility.
|
|
*
|
|
* @param {Boolean} [options.fillAlways=false]
|
|
* Normally, modals are automatically filled only the first time
|
|
* they open. This tells the modal to refresh its content
|
|
* every time it opens.
|
|
*
|
|
* @param {String} [options.label]
|
|
* A text label for the modal, primarily for accessibility.
|
|
*
|
|
* @param {Boolean} [options.temporary=true]
|
|
* If `true`, the modal can only be opened once; it will be
|
|
* disposed as soon as it's closed.
|
|
*
|
|
* @param {Boolean} [options.uncloseable=false]
|
|
* If `true`, the user will not be able to close the modal
|
|
* through the UI in the normal ways. Programmatic closing is
|
|
* still possible.
|
|
*
|
|
*/
|
|
|
|
function ModalDialog(player, options) {
|
|
_classCallCheck(this, ModalDialog);
|
|
|
|
_Component.call(this, player, options);
|
|
this.opened_ = this.hasBeenOpened_ = this.hasBeenFilled_ = false;
|
|
|
|
this.closeable(!this.options_.uncloseable);
|
|
this.content(this.options_.content);
|
|
|
|
// Make sure the contentEl is defined AFTER any children are initialized
|
|
// because we only want the contents of the modal in the contentEl
|
|
// (not the UI elements like the close button).
|
|
this.contentEl_ = Dom.createEl('div', {
|
|
className: MODAL_CLASS_NAME + '-content'
|
|
}, {
|
|
role: 'document'
|
|
});
|
|
|
|
this.descEl_ = Dom.createEl('p', {
|
|
className: MODAL_CLASS_NAME + '-description vjs-offscreen',
|
|
id: this.el().getAttribute('aria-describedby')
|
|
});
|
|
|
|
Dom.textContent(this.descEl_, this.description());
|
|
this.el_.appendChild(this.descEl_);
|
|
this.el_.appendChild(this.contentEl_);
|
|
}
|
|
|
|
/*
|
|
* Modal dialog default options.
|
|
*
|
|
* @type {Object}
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Create the modal's DOM element
|
|
*
|
|
* @method createEl
|
|
* @return {Element}
|
|
*/
|
|
|
|
ModalDialog.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: this.buildCSSClass(),
|
|
tabIndex: -1
|
|
}, {
|
|
'aria-describedby': this.id() + '_description',
|
|
'aria-hidden': 'true',
|
|
'aria-label': this.label(),
|
|
role: 'dialog'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Build the modal's CSS class.
|
|
*
|
|
* @method buildCSSClass
|
|
* @return {String}
|
|
*/
|
|
|
|
ModalDialog.prototype.buildCSSClass = function buildCSSClass() {
|
|
return MODAL_CLASS_NAME + ' vjs-hidden ' + _Component.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
/**
|
|
* Handles key presses on the document, looking for ESC, which closes
|
|
* the modal.
|
|
*
|
|
* @method handleKeyPress
|
|
* @param {Event} e
|
|
*/
|
|
|
|
ModalDialog.prototype.handleKeyPress = function handleKeyPress(e) {
|
|
if (e.which === ESC && this.closeable()) {
|
|
this.close();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the label string for this modal. Primarily used for accessibility.
|
|
*
|
|
* @return {String}
|
|
*/
|
|
|
|
ModalDialog.prototype.label = function label() {
|
|
return this.options_.label || this.localize('Modal Window');
|
|
};
|
|
|
|
/**
|
|
* Returns the description string for this modal. Primarily used for
|
|
* accessibility.
|
|
*
|
|
* @return {String}
|
|
*/
|
|
|
|
ModalDialog.prototype.description = function description() {
|
|
var desc = this.options_.description || this.localize('This is a modal window.');
|
|
|
|
// Append a universal closeability message if the modal is closeable.
|
|
if (this.closeable()) {
|
|
desc += ' ' + this.localize('This modal can be closed by pressing the Escape key or activating the close button.');
|
|
}
|
|
|
|
return desc;
|
|
};
|
|
|
|
/**
|
|
* Opens the modal.
|
|
*
|
|
* @method open
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
ModalDialog.prototype.open = function open() {
|
|
if (!this.opened_) {
|
|
var player = this.player();
|
|
|
|
this.trigger('beforemodalopen');
|
|
this.opened_ = true;
|
|
|
|
// Fill content if the modal has never opened before and
|
|
// never been filled.
|
|
if (this.options_.fillAlways || !this.hasBeenOpened_ && !this.hasBeenFilled_) {
|
|
this.fill();
|
|
}
|
|
|
|
// If the player was playing, pause it and take note of its previously
|
|
// playing state.
|
|
this.wasPlaying_ = !player.paused();
|
|
|
|
if (this.wasPlaying_) {
|
|
player.pause();
|
|
}
|
|
|
|
if (this.closeable()) {
|
|
this.on(this.el_.ownerDocument, 'keydown', Fn.bind(this, this.handleKeyPress));
|
|
}
|
|
|
|
player.controls(false);
|
|
this.show();
|
|
this.el().setAttribute('aria-hidden', 'false');
|
|
this.trigger('modalopen');
|
|
this.hasBeenOpened_ = true;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Whether or not the modal is opened currently.
|
|
*
|
|
* @method opened
|
|
* @param {Boolean} [value]
|
|
* If given, it will open (`true`) or close (`false`) the modal.
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
|
|
ModalDialog.prototype.opened = function opened(value) {
|
|
if (typeof value === 'boolean') {
|
|
this[value ? 'open' : 'close']();
|
|
}
|
|
return this.opened_;
|
|
};
|
|
|
|
/**
|
|
* Closes the modal.
|
|
*
|
|
* @method close
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
ModalDialog.prototype.close = function close() {
|
|
if (this.opened_) {
|
|
var player = this.player();
|
|
|
|
this.trigger('beforemodalclose');
|
|
this.opened_ = false;
|
|
|
|
if (this.wasPlaying_) {
|
|
player.play();
|
|
}
|
|
|
|
if (this.closeable()) {
|
|
this.off(this.el_.ownerDocument, 'keydown', Fn.bind(this, this.handleKeyPress));
|
|
}
|
|
|
|
player.controls(true);
|
|
this.hide();
|
|
this.el().setAttribute('aria-hidden', 'true');
|
|
this.trigger('modalclose');
|
|
|
|
if (this.options_.temporary) {
|
|
this.dispose();
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Whether or not the modal is closeable via the UI.
|
|
*
|
|
* @method closeable
|
|
* @param {Boolean} [value]
|
|
* If given as a Boolean, it will set the `closeable` option.
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
|
|
ModalDialog.prototype.closeable = function closeable(value) {
|
|
if (typeof value === 'boolean') {
|
|
var closeable = this.closeable_ = !!value;
|
|
var _close = this.getChild('closeButton');
|
|
|
|
// If this is being made closeable and has no close button, add one.
|
|
if (closeable && !_close) {
|
|
|
|
// The close button should be a child of the modal - not its
|
|
// content element, so temporarily change the content element.
|
|
var temp = this.contentEl_;
|
|
this.contentEl_ = this.el_;
|
|
_close = this.addChild('closeButton');
|
|
this.contentEl_ = temp;
|
|
this.on(_close, 'close', this.close);
|
|
}
|
|
|
|
// If this is being made uncloseable and has a close button, remove it.
|
|
if (!closeable && _close) {
|
|
this.off(_close, 'close', this.close);
|
|
this.removeChild(_close);
|
|
_close.dispose();
|
|
}
|
|
}
|
|
return this.closeable_;
|
|
};
|
|
|
|
/**
|
|
* Fill the modal's content element with the modal's "content" option.
|
|
*
|
|
* The content element will be emptied before this change takes place.
|
|
*
|
|
* @method fill
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
ModalDialog.prototype.fill = function fill() {
|
|
return this.fillWith(this.content());
|
|
};
|
|
|
|
/**
|
|
* Fill the modal's content element with arbitrary content.
|
|
*
|
|
* The content element will be emptied before this change takes place.
|
|
*
|
|
* @method fillWith
|
|
* @param {Mixed} [content]
|
|
* The same rules apply to this as apply to the `content` option.
|
|
*
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
ModalDialog.prototype.fillWith = function fillWith(content) {
|
|
var contentEl = this.contentEl();
|
|
var parentEl = contentEl.parentNode;
|
|
var nextSiblingEl = contentEl.nextSibling;
|
|
|
|
this.trigger('beforemodalfill');
|
|
this.hasBeenFilled_ = true;
|
|
|
|
// Detach the content element from the DOM before performing
|
|
// manipulation to avoid modifying the live DOM multiple times.
|
|
parentEl.removeChild(contentEl);
|
|
this.empty();
|
|
Dom.insertContent(contentEl, content);
|
|
this.trigger('modalfill');
|
|
|
|
// Re-inject the re-filled content element.
|
|
if (nextSiblingEl) {
|
|
parentEl.insertBefore(contentEl, nextSiblingEl);
|
|
} else {
|
|
parentEl.appendChild(contentEl);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Empties the content element.
|
|
*
|
|
* This happens automatically anytime the modal is filled.
|
|
*
|
|
* @method empty
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
ModalDialog.prototype.empty = function empty() {
|
|
this.trigger('beforemodalempty');
|
|
Dom.emptyEl(this.contentEl());
|
|
this.trigger('modalempty');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Gets or sets the modal content, which gets normalized before being
|
|
* rendered into the DOM.
|
|
*
|
|
* This does not update the DOM or fill the modal, but it is called during
|
|
* that process.
|
|
*
|
|
* @method content
|
|
* @param {Mixed} [value]
|
|
* If defined, sets the internal content value to be used on the
|
|
* next call(s) to `fill`. This value is normalized before being
|
|
* inserted. To "clear" the internal content value, pass `null`.
|
|
*
|
|
* @return {Mixed}
|
|
*/
|
|
|
|
ModalDialog.prototype.content = function content(value) {
|
|
if (typeof value !== 'undefined') {
|
|
this.content_ = value;
|
|
}
|
|
return this.content_;
|
|
};
|
|
|
|
return ModalDialog;
|
|
})(_component2['default']);
|
|
|
|
ModalDialog.prototype.options_ = {
|
|
temporary: true
|
|
};
|
|
|
|
_component2['default'].registerComponent('ModalDialog', ModalDialog);
|
|
exports['default'] = ModalDialog;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./close-button":66,"./component":67,"./utils/dom":143,"./utils/fn":145,"./utils/log":148}],113:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file player.js
|
|
*/
|
|
// Subclasses Component
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('./component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _utilsDomJs = _dereq_('./utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsGuidJs = _dereq_('./utils/guid.js');
|
|
|
|
var Guid = _interopRequireWildcard(_utilsGuidJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('./utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _utilsLogJs = _dereq_('./utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('./utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
var _utilsTimeRangesJs = _dereq_('./utils/time-ranges.js');
|
|
|
|
var _utilsBufferJs = _dereq_('./utils/buffer.js');
|
|
|
|
var _utilsStylesheetJs = _dereq_('./utils/stylesheet.js');
|
|
|
|
var stylesheet = _interopRequireWildcard(_utilsStylesheetJs);
|
|
|
|
var _fullscreenApiJs = _dereq_('./fullscreen-api.js');
|
|
|
|
var _fullscreenApiJs2 = _interopRequireDefault(_fullscreenApiJs);
|
|
|
|
var _mediaErrorJs = _dereq_('./media-error.js');
|
|
|
|
var _mediaErrorJs2 = _interopRequireDefault(_mediaErrorJs);
|
|
|
|
var _safeJsonParseTuple = _dereq_('safe-json-parse/tuple');
|
|
|
|
var _safeJsonParseTuple2 = _interopRequireDefault(_safeJsonParseTuple);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var _utilsMergeOptionsJs = _dereq_('./utils/merge-options.js');
|
|
|
|
var _utilsMergeOptionsJs2 = _interopRequireDefault(_utilsMergeOptionsJs);
|
|
|
|
var _tracksTextTrackListConverterJs = _dereq_('./tracks/text-track-list-converter.js');
|
|
|
|
var _tracksTextTrackListConverterJs2 = _interopRequireDefault(_tracksTextTrackListConverterJs);
|
|
|
|
var _tracksAudioTrackListJs = _dereq_('./tracks/audio-track-list.js');
|
|
|
|
var _tracksAudioTrackListJs2 = _interopRequireDefault(_tracksAudioTrackListJs);
|
|
|
|
var _tracksVideoTrackListJs = _dereq_('./tracks/video-track-list.js');
|
|
|
|
var _tracksVideoTrackListJs2 = _interopRequireDefault(_tracksVideoTrackListJs);
|
|
|
|
// Include required child components (importing also registers them)
|
|
|
|
var _techLoaderJs = _dereq_('./tech/loader.js');
|
|
|
|
var _techLoaderJs2 = _interopRequireDefault(_techLoaderJs);
|
|
|
|
var _posterImageJs = _dereq_('./poster-image.js');
|
|
|
|
var _posterImageJs2 = _interopRequireDefault(_posterImageJs);
|
|
|
|
var _tracksTextTrackDisplayJs = _dereq_('./tracks/text-track-display.js');
|
|
|
|
var _tracksTextTrackDisplayJs2 = _interopRequireDefault(_tracksTextTrackDisplayJs);
|
|
|
|
var _loadingSpinnerJs = _dereq_('./loading-spinner.js');
|
|
|
|
var _loadingSpinnerJs2 = _interopRequireDefault(_loadingSpinnerJs);
|
|
|
|
var _bigPlayButtonJs = _dereq_('./big-play-button.js');
|
|
|
|
var _bigPlayButtonJs2 = _interopRequireDefault(_bigPlayButtonJs);
|
|
|
|
var _controlBarControlBarJs = _dereq_('./control-bar/control-bar.js');
|
|
|
|
var _controlBarControlBarJs2 = _interopRequireDefault(_controlBarControlBarJs);
|
|
|
|
var _errorDisplayJs = _dereq_('./error-display.js');
|
|
|
|
var _errorDisplayJs2 = _interopRequireDefault(_errorDisplayJs);
|
|
|
|
var _tracksTextTrackSettingsJs = _dereq_('./tracks/text-track-settings.js');
|
|
|
|
var _tracksTextTrackSettingsJs2 = _interopRequireDefault(_tracksTextTrackSettingsJs);
|
|
|
|
var _modalDialog = _dereq_('./modal-dialog');
|
|
|
|
var _modalDialog2 = _interopRequireDefault(_modalDialog);
|
|
|
|
// Require html5 tech, at least for disposing the original video tag
|
|
|
|
var _techTechJs = _dereq_('./tech/tech.js');
|
|
|
|
var _techTechJs2 = _interopRequireDefault(_techTechJs);
|
|
|
|
var _techHtml5Js = _dereq_('./tech/html5.js');
|
|
|
|
var _techHtml5Js2 = _interopRequireDefault(_techHtml5Js);
|
|
|
|
/**
|
|
* An instance of the `Player` class is created when any of the Video.js setup methods are used to initialize a video.
|
|
* ```js
|
|
* var myPlayer = videojs('example_video_1');
|
|
* ```
|
|
* In the following example, the `data-setup` attribute tells the Video.js library to create a player instance when the library is ready.
|
|
* ```html
|
|
* <video id="example_video_1" data-setup='{}' controls>
|
|
* <source src="my-source.mp4" type="video/mp4">
|
|
* </video>
|
|
* ```
|
|
* After an instance has been created it can be accessed globally using `Video('example_video_1')`.
|
|
*
|
|
* @param {Element} tag The original video tag used for configuring options
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Component
|
|
* @class Player
|
|
*/
|
|
|
|
var Player = (function (_Component) {
|
|
_inherits(Player, _Component);
|
|
|
|
/**
|
|
* player's constructor function
|
|
*
|
|
* @constructs
|
|
* @method init
|
|
* @param {Element} tag The original video tag used for configuring options
|
|
* @param {Object=} options Player options
|
|
* @param {Function=} ready Ready callback function
|
|
*/
|
|
|
|
function Player(tag, options, ready) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, Player);
|
|
|
|
// Make sure tag ID exists
|
|
tag.id = tag.id || 'vjs_video_' + Guid.newGUID();
|
|
|
|
// Set Options
|
|
// The options argument overrides options set in the video tag
|
|
// which overrides globally set options.
|
|
// This latter part coincides with the load order
|
|
// (tag must exist before Player)
|
|
options = _objectAssign2['default'](Player.getTagSettings(tag), options);
|
|
|
|
// Delay the initialization of children because we need to set up
|
|
// player properties first, and can't use `this` before `super()`
|
|
options.initChildren = false;
|
|
|
|
// Same with creating the element
|
|
options.createEl = false;
|
|
|
|
// we don't want the player to report touch activity on itself
|
|
// see enableTouchActivity in Component
|
|
options.reportTouchActivity = false;
|
|
|
|
// Run base component initializing with new options
|
|
_Component.call(this, null, options, ready);
|
|
|
|
// if the global option object was accidentally blown away by
|
|
// someone, bail early with an informative error
|
|
if (!this.options_ || !this.options_.techOrder || !this.options_.techOrder.length) {
|
|
throw new Error('No techOrder specified. Did you overwrite ' + 'videojs.options instead of just changing the ' + 'properties you want to override?');
|
|
}
|
|
|
|
this.tag = tag; // Store the original tag used to set options
|
|
|
|
// Store the tag attributes used to restore html5 element
|
|
this.tagAttributes = tag && Dom.getElAttributes(tag);
|
|
|
|
// Update current language
|
|
this.language(this.options_.language);
|
|
|
|
// Update Supported Languages
|
|
if (options.languages) {
|
|
(function () {
|
|
// Normalise player option languages to lowercase
|
|
var languagesToLower = {};
|
|
|
|
Object.getOwnPropertyNames(options.languages).forEach(function (name) {
|
|
languagesToLower[name.toLowerCase()] = options.languages[name];
|
|
});
|
|
_this.languages_ = languagesToLower;
|
|
})();
|
|
} else {
|
|
this.languages_ = Player.prototype.options_.languages;
|
|
}
|
|
|
|
// Cache for video property values.
|
|
this.cache_ = {};
|
|
|
|
// Set poster
|
|
this.poster_ = options.poster || '';
|
|
|
|
// Set controls
|
|
this.controls_ = !!options.controls;
|
|
|
|
// Original tag settings stored in options
|
|
// now remove immediately so native controls don't flash.
|
|
// May be turned back on by HTML5 tech if nativeControlsForTouch is true
|
|
tag.controls = false;
|
|
|
|
/*
|
|
* Store the internal state of scrubbing
|
|
*
|
|
* @private
|
|
* @return {Boolean} True if the user is scrubbing
|
|
*/
|
|
this.scrubbing_ = false;
|
|
|
|
this.el_ = this.createEl();
|
|
|
|
// We also want to pass the original player options to each component and plugin
|
|
// as well so they don't need to reach back into the player for options later.
|
|
// We also need to do another copy of this.options_ so we don't end up with
|
|
// an infinite loop.
|
|
var playerOptionsCopy = _utilsMergeOptionsJs2['default'](this.options_);
|
|
|
|
// Load plugins
|
|
if (options.plugins) {
|
|
(function () {
|
|
var plugins = options.plugins;
|
|
|
|
Object.getOwnPropertyNames(plugins).forEach(function (name) {
|
|
if (typeof this[name] === 'function') {
|
|
this[name](plugins[name]);
|
|
} else {
|
|
_utilsLogJs2['default'].error('Unable to find plugin:', name);
|
|
}
|
|
}, _this);
|
|
})();
|
|
}
|
|
|
|
this.options_.playerOptions = playerOptionsCopy;
|
|
|
|
this.initChildren();
|
|
|
|
// Set isAudio based on whether or not an audio tag was used
|
|
this.isAudio(tag.nodeName.toLowerCase() === 'audio');
|
|
|
|
// Update controls className. Can't do this when the controls are initially
|
|
// set because the element doesn't exist yet.
|
|
if (this.controls()) {
|
|
this.addClass('vjs-controls-enabled');
|
|
} else {
|
|
this.addClass('vjs-controls-disabled');
|
|
}
|
|
|
|
// Set ARIA label and region role depending on player type
|
|
this.el_.setAttribute('role', 'region');
|
|
if (this.isAudio()) {
|
|
this.el_.setAttribute('aria-label', 'audio player');
|
|
} else {
|
|
this.el_.setAttribute('aria-label', 'video player');
|
|
}
|
|
|
|
if (this.isAudio()) {
|
|
this.addClass('vjs-audio');
|
|
}
|
|
|
|
if (this.flexNotSupported_()) {
|
|
this.addClass('vjs-no-flex');
|
|
}
|
|
|
|
// TODO: Make this smarter. Toggle user state between touching/mousing
|
|
// using events, since devices can have both touch and mouse events.
|
|
// if (browser.TOUCH_ENABLED) {
|
|
// this.addClass('vjs-touch-enabled');
|
|
// }
|
|
|
|
// iOS Safari has broken hover handling
|
|
if (!browser.IS_IOS) {
|
|
this.addClass('vjs-workinghover');
|
|
}
|
|
|
|
// Make player easily findable by ID
|
|
Player.players[this.id_] = this;
|
|
|
|
// When the player is first initialized, trigger activity so components
|
|
// like the control bar show themselves if needed
|
|
this.userActive(true);
|
|
this.reportUserActivity();
|
|
this.listenForUserActivity_();
|
|
|
|
this.on('fullscreenchange', this.handleFullscreenChange_);
|
|
this.on('stageclick', this.handleStageClick_);
|
|
}
|
|
|
|
/*
|
|
* Global player list
|
|
*
|
|
* @type {Object}
|
|
*/
|
|
|
|
/**
|
|
* Destroys the video player and does any necessary cleanup
|
|
* ```js
|
|
* myPlayer.dispose();
|
|
* ```
|
|
* This is especially helpful if you are dynamically adding and removing videos
|
|
* to/from the DOM.
|
|
*
|
|
* @method dispose
|
|
*/
|
|
|
|
Player.prototype.dispose = function dispose() {
|
|
this.trigger('dispose');
|
|
// prevent dispose from being called twice
|
|
this.off('dispose');
|
|
|
|
if (this.styleEl_ && this.styleEl_.parentNode) {
|
|
this.styleEl_.parentNode.removeChild(this.styleEl_);
|
|
}
|
|
|
|
// Kill reference to this player
|
|
Player.players[this.id_] = null;
|
|
if (this.tag && this.tag.player) {
|
|
this.tag.player = null;
|
|
}
|
|
if (this.el_ && this.el_.player) {
|
|
this.el_.player = null;
|
|
}
|
|
|
|
if (this.tech_) {
|
|
this.tech_.dispose();
|
|
}
|
|
|
|
_Component.prototype.dispose.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Player.prototype.createEl = function createEl() {
|
|
var el = this.el_ = _Component.prototype.createEl.call(this, 'div');
|
|
var tag = this.tag;
|
|
|
|
// Remove width/height attrs from tag so CSS can make it 100% width/height
|
|
tag.removeAttribute('width');
|
|
tag.removeAttribute('height');
|
|
|
|
// Copy over all the attributes from the tag, including ID and class
|
|
// ID will now reference player box, not the video tag
|
|
var attrs = Dom.getElAttributes(tag);
|
|
|
|
Object.getOwnPropertyNames(attrs).forEach(function (attr) {
|
|
// workaround so we don't totally break IE7
|
|
// http://stackoverflow.com/questions/3653444/css-styles-not-applied-on-dynamic-elements-in-internet-explorer-7
|
|
if (attr === 'class') {
|
|
el.className = attrs[attr];
|
|
} else {
|
|
el.setAttribute(attr, attrs[attr]);
|
|
}
|
|
});
|
|
|
|
// Update tag id/class for use as HTML5 playback tech
|
|
// Might think we should do this after embedding in container so .vjs-tech class
|
|
// doesn't flash 100% width/height, but class only applies with .video-js parent
|
|
tag.playerId = tag.id;
|
|
tag.id += '_html5_api';
|
|
tag.className = 'vjs-tech';
|
|
|
|
// Make player findable on elements
|
|
tag.player = el.player = this;
|
|
// Default state of video is paused
|
|
this.addClass('vjs-paused');
|
|
|
|
// Add a style element in the player that we'll use to set the width/height
|
|
// of the player in a way that's still overrideable by CSS, just like the
|
|
// video element
|
|
if (_globalWindow2['default'].VIDEOJS_NO_DYNAMIC_STYLE !== true) {
|
|
this.styleEl_ = stylesheet.createStyleElement('vjs-styles-dimensions');
|
|
var defaultsStyleEl = Dom.$('.vjs-styles-defaults');
|
|
var head = Dom.$('head');
|
|
head.insertBefore(this.styleEl_, defaultsStyleEl ? defaultsStyleEl.nextSibling : head.firstChild);
|
|
}
|
|
|
|
// Pass in the width/height/aspectRatio options which will update the style el
|
|
this.width(this.options_.width);
|
|
this.height(this.options_.height);
|
|
this.fluid(this.options_.fluid);
|
|
this.aspectRatio(this.options_.aspectRatio);
|
|
|
|
// Hide any links within the video/audio tag, because IE doesn't hide them completely.
|
|
var links = tag.getElementsByTagName('a');
|
|
for (var i = 0; i < links.length; i++) {
|
|
var linkEl = links.item(i);
|
|
Dom.addElClass(linkEl, 'vjs-hidden');
|
|
linkEl.setAttribute('hidden', 'hidden');
|
|
}
|
|
|
|
// insertElFirst seems to cause the networkState to flicker from 3 to 2, so
|
|
// keep track of the original for later so we can know if the source originally failed
|
|
tag.initNetworkState_ = tag.networkState;
|
|
|
|
// Wrap video tag in div (el/box) container
|
|
if (tag.parentNode) {
|
|
tag.parentNode.insertBefore(el, tag);
|
|
}
|
|
|
|
// insert the tag as the first child of the player element
|
|
// then manually add it to the children array so that this.addChild
|
|
// will work properly for other components
|
|
Dom.insertElFirst(tag, el); // Breaks iPhone, fixed in HTML5 setup.
|
|
this.children_.unshift(tag);
|
|
|
|
this.el_ = el;
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Get/set player width
|
|
*
|
|
* @param {Number=} value Value for width
|
|
* @return {Number} Width when getting
|
|
* @method width
|
|
*/
|
|
|
|
Player.prototype.width = function width(value) {
|
|
return this.dimension('width', value);
|
|
};
|
|
|
|
/**
|
|
* Get/set player height
|
|
*
|
|
* @param {Number=} value Value for height
|
|
* @return {Number} Height when getting
|
|
* @method height
|
|
*/
|
|
|
|
Player.prototype.height = function height(value) {
|
|
return this.dimension('height', value);
|
|
};
|
|
|
|
/**
|
|
* Get/set dimension for player
|
|
*
|
|
* @param {String} dimension Either width or height
|
|
* @param {Number=} value Value for dimension
|
|
* @return {Component}
|
|
* @method dimension
|
|
*/
|
|
|
|
Player.prototype.dimension = function dimension(_dimension, value) {
|
|
var privDimension = _dimension + '_';
|
|
|
|
if (value === undefined) {
|
|
return this[privDimension] || 0;
|
|
}
|
|
|
|
if (value === '') {
|
|
// If an empty string is given, reset the dimension to be automatic
|
|
this[privDimension] = undefined;
|
|
} else {
|
|
var parsedVal = parseFloat(value);
|
|
|
|
if (isNaN(parsedVal)) {
|
|
_utilsLogJs2['default'].error('Improper value "' + value + '" supplied for for ' + _dimension);
|
|
return this;
|
|
}
|
|
|
|
this[privDimension] = parsedVal;
|
|
}
|
|
|
|
this.updateStyleEl_();
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add/remove the vjs-fluid class
|
|
*
|
|
* @param {Boolean} bool Value of true adds the class, value of false removes the class
|
|
* @method fluid
|
|
*/
|
|
|
|
Player.prototype.fluid = function fluid(bool) {
|
|
if (bool === undefined) {
|
|
return !!this.fluid_;
|
|
}
|
|
|
|
this.fluid_ = !!bool;
|
|
|
|
if (bool) {
|
|
this.addClass('vjs-fluid');
|
|
} else {
|
|
this.removeClass('vjs-fluid');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get/Set the aspect ratio
|
|
*
|
|
* @param {String=} ratio Aspect ratio for player
|
|
* @return aspectRatio
|
|
* @method aspectRatio
|
|
*/
|
|
|
|
Player.prototype.aspectRatio = function aspectRatio(ratio) {
|
|
if (ratio === undefined) {
|
|
return this.aspectRatio_;
|
|
}
|
|
|
|
// Check for width:height format
|
|
if (!/^\d+\:\d+$/.test(ratio)) {
|
|
throw new Error('Improper value supplied for aspect ratio. The format should be width:height, for example 16:9.');
|
|
}
|
|
this.aspectRatio_ = ratio;
|
|
|
|
// We're assuming if you set an aspect ratio you want fluid mode,
|
|
// because in fixed mode you could calculate width and height yourself.
|
|
this.fluid(true);
|
|
|
|
this.updateStyleEl_();
|
|
};
|
|
|
|
/**
|
|
* Update styles of the player element (height, width and aspect ratio)
|
|
*
|
|
* @method updateStyleEl_
|
|
*/
|
|
|
|
Player.prototype.updateStyleEl_ = function updateStyleEl_() {
|
|
if (_globalWindow2['default'].VIDEOJS_NO_DYNAMIC_STYLE === true) {
|
|
var _width = typeof this.width_ === 'number' ? this.width_ : this.options_.width;
|
|
var _height = typeof this.height_ === 'number' ? this.height_ : this.options_.height;
|
|
var techEl = this.tech_ && this.tech_.el();
|
|
|
|
if (techEl) {
|
|
if (_width >= 0) {
|
|
techEl.width = _width;
|
|
}
|
|
if (_height >= 0) {
|
|
techEl.height = _height;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var width = undefined;
|
|
var height = undefined;
|
|
var aspectRatio = undefined;
|
|
var idClass = undefined;
|
|
|
|
// The aspect ratio is either used directly or to calculate width and height.
|
|
if (this.aspectRatio_ !== undefined && this.aspectRatio_ !== 'auto') {
|
|
// Use any aspectRatio that's been specifically set
|
|
aspectRatio = this.aspectRatio_;
|
|
} else if (this.videoWidth()) {
|
|
// Otherwise try to get the aspect ratio from the video metadata
|
|
aspectRatio = this.videoWidth() + ':' + this.videoHeight();
|
|
} else {
|
|
// Or use a default. The video element's is 2:1, but 16:9 is more common.
|
|
aspectRatio = '16:9';
|
|
}
|
|
|
|
// Get the ratio as a decimal we can use to calculate dimensions
|
|
var ratioParts = aspectRatio.split(':');
|
|
var ratioMultiplier = ratioParts[1] / ratioParts[0];
|
|
|
|
if (this.width_ !== undefined) {
|
|
// Use any width that's been specifically set
|
|
width = this.width_;
|
|
} else if (this.height_ !== undefined) {
|
|
// Or calulate the width from the aspect ratio if a height has been set
|
|
width = this.height_ / ratioMultiplier;
|
|
} else {
|
|
// Or use the video's metadata, or use the video el's default of 300
|
|
width = this.videoWidth() || 300;
|
|
}
|
|
|
|
if (this.height_ !== undefined) {
|
|
// Use any height that's been specifically set
|
|
height = this.height_;
|
|
} else {
|
|
// Otherwise calculate the height from the ratio and the width
|
|
height = width * ratioMultiplier;
|
|
}
|
|
|
|
// Ensure the CSS class is valid by starting with an alpha character
|
|
if (/^[^a-zA-Z]/.test(this.id())) {
|
|
idClass = 'dimensions-' + this.id();
|
|
} else {
|
|
idClass = this.id() + '-dimensions';
|
|
}
|
|
|
|
// Ensure the right class is still on the player for the style element
|
|
this.addClass(idClass);
|
|
|
|
stylesheet.setTextContent(this.styleEl_, '\n .' + idClass + ' {\n width: ' + width + 'px;\n height: ' + height + 'px;\n }\n\n .' + idClass + '.vjs-fluid {\n padding-top: ' + ratioMultiplier * 100 + '%;\n }\n ');
|
|
};
|
|
|
|
/**
|
|
* Load the Media Playback Technology (tech)
|
|
* Load/Create an instance of playback technology including element and API methods
|
|
* And append playback element in player div.
|
|
*
|
|
* @param {String} techName Name of the playback technology
|
|
* @param {String} source Video source
|
|
* @method loadTech_
|
|
* @private
|
|
*/
|
|
|
|
Player.prototype.loadTech_ = function loadTech_(techName, source) {
|
|
|
|
// Pause and remove current playback technology
|
|
if (this.tech_) {
|
|
this.unloadTech_();
|
|
}
|
|
|
|
// get rid of the HTML5 video tag as soon as we are using another tech
|
|
if (techName !== 'Html5' && this.tag) {
|
|
_techTechJs2['default'].getTech('Html5').disposeMediaElement(this.tag);
|
|
this.tag.player = null;
|
|
this.tag = null;
|
|
}
|
|
|
|
this.techName_ = techName;
|
|
|
|
// Turn off API access because we're loading a new tech that might load asynchronously
|
|
this.isReady_ = false;
|
|
|
|
// Grab tech-specific options from player options and add source and parent element to use.
|
|
var techOptions = _objectAssign2['default']({
|
|
'nativeControlsForTouch': this.options_.nativeControlsForTouch,
|
|
'source': source,
|
|
'playerId': this.id(),
|
|
'techId': this.id() + '_' + techName + '_api',
|
|
'videoTracks': this.videoTracks_,
|
|
'textTracks': this.textTracks_,
|
|
'audioTracks': this.audioTracks_,
|
|
'autoplay': this.options_.autoplay,
|
|
'preload': this.options_.preload,
|
|
'loop': this.options_.loop,
|
|
'muted': this.options_.muted,
|
|
'poster': this.poster(),
|
|
'language': this.language(),
|
|
'vtt.js': this.options_['vtt.js']
|
|
}, this.options_[techName.toLowerCase()]);
|
|
|
|
if (this.tag) {
|
|
techOptions.tag = this.tag;
|
|
}
|
|
|
|
if (source) {
|
|
this.currentType_ = source.type;
|
|
if (source.src === this.cache_.src && this.cache_.currentTime > 0) {
|
|
techOptions.startTime = this.cache_.currentTime;
|
|
}
|
|
|
|
this.cache_.src = source.src;
|
|
}
|
|
|
|
// Initialize tech instance
|
|
var techComponent = _techTechJs2['default'].getTech(techName);
|
|
// Support old behavior of techs being registered as components.
|
|
// Remove once that deprecated behavior is removed.
|
|
if (!techComponent) {
|
|
techComponent = _componentJs2['default'].getComponent(techName);
|
|
}
|
|
this.tech_ = new techComponent(techOptions);
|
|
|
|
// player.triggerReady is always async, so don't need this to be async
|
|
this.tech_.ready(Fn.bind(this, this.handleTechReady_), true);
|
|
|
|
_tracksTextTrackListConverterJs2['default'].jsonToTextTracks(this.textTracksJson_ || [], this.tech_);
|
|
|
|
// Listen to all HTML5-defined events and trigger them on the player
|
|
this.on(this.tech_, 'loadstart', this.handleTechLoadStart_);
|
|
this.on(this.tech_, 'waiting', this.handleTechWaiting_);
|
|
this.on(this.tech_, 'canplay', this.handleTechCanPlay_);
|
|
this.on(this.tech_, 'canplaythrough', this.handleTechCanPlayThrough_);
|
|
this.on(this.tech_, 'playing', this.handleTechPlaying_);
|
|
this.on(this.tech_, 'ended', this.handleTechEnded_);
|
|
this.on(this.tech_, 'seeking', this.handleTechSeeking_);
|
|
this.on(this.tech_, 'seeked', this.handleTechSeeked_);
|
|
this.on(this.tech_, 'play', this.handleTechPlay_);
|
|
this.on(this.tech_, 'firstplay', this.handleTechFirstPlay_);
|
|
this.on(this.tech_, 'pause', this.handleTechPause_);
|
|
this.on(this.tech_, 'progress', this.handleTechProgress_);
|
|
this.on(this.tech_, 'durationchange', this.handleTechDurationChange_);
|
|
this.on(this.tech_, 'fullscreenchange', this.handleTechFullscreenChange_);
|
|
this.on(this.tech_, 'error', this.handleTechError_);
|
|
this.on(this.tech_, 'suspend', this.handleTechSuspend_);
|
|
this.on(this.tech_, 'abort', this.handleTechAbort_);
|
|
this.on(this.tech_, 'emptied', this.handleTechEmptied_);
|
|
this.on(this.tech_, 'stalled', this.handleTechStalled_);
|
|
this.on(this.tech_, 'loadedmetadata', this.handleTechLoadedMetaData_);
|
|
this.on(this.tech_, 'loadeddata', this.handleTechLoadedData_);
|
|
this.on(this.tech_, 'timeupdate', this.handleTechTimeUpdate_);
|
|
this.on(this.tech_, 'ratechange', this.handleTechRateChange_);
|
|
this.on(this.tech_, 'volumechange', this.handleTechVolumeChange_);
|
|
this.on(this.tech_, 'texttrackchange', this.handleTechTextTrackChange_);
|
|
this.on(this.tech_, 'loadedmetadata', this.updateStyleEl_);
|
|
this.on(this.tech_, 'posterchange', this.handleTechPosterChange_);
|
|
|
|
this.usingNativeControls(this.techGet_('controls'));
|
|
|
|
if (this.controls() && !this.usingNativeControls()) {
|
|
this.addTechControlsListeners_();
|
|
}
|
|
|
|
// Add the tech element in the DOM if it was not already there
|
|
// Make sure to not insert the original video element if using Html5
|
|
if (this.tech_.el().parentNode !== this.el() && (techName !== 'Html5' || !this.tag)) {
|
|
Dom.insertElFirst(this.tech_.el(), this.el());
|
|
}
|
|
|
|
// Get rid of the original video tag reference after the first tech is loaded
|
|
if (this.tag) {
|
|
this.tag.player = null;
|
|
this.tag = null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Unload playback technology
|
|
*
|
|
* @method unloadTech_
|
|
* @private
|
|
*/
|
|
|
|
Player.prototype.unloadTech_ = function unloadTech_() {
|
|
// Save the current text tracks so that we can reuse the same text tracks with the next tech
|
|
this.videoTracks_ = this.videoTracks();
|
|
this.textTracks_ = this.textTracks();
|
|
this.audioTracks_ = this.audioTracks();
|
|
this.textTracksJson_ = _tracksTextTrackListConverterJs2['default'].textTracksToJson(this.tech_);
|
|
|
|
this.isReady_ = false;
|
|
|
|
this.tech_.dispose();
|
|
|
|
this.tech_ = false;
|
|
};
|
|
|
|
/**
|
|
* Return a reference to the current tech.
|
|
* It will only return a reference to the tech if given an object with the
|
|
* `IWillNotUseThisInPlugins` property on it. This is try and prevent misuse
|
|
* of techs by plugins.
|
|
*
|
|
* @param {Object}
|
|
* @return {Object} The Tech
|
|
* @method tech
|
|
*/
|
|
|
|
Player.prototype.tech = function tech(safety) {
|
|
if (safety && safety.IWillNotUseThisInPlugins) {
|
|
return this.tech_;
|
|
}
|
|
var errorText = '\n Please make sure that you are not using this inside of a plugin.\n To disable this alert and error, please pass in an object with\n `IWillNotUseThisInPlugins` to the `tech` method. See\n https://github.com/videojs/video.js/issues/2617 for more info.\n ';
|
|
_globalWindow2['default'].alert(errorText);
|
|
throw new Error(errorText);
|
|
};
|
|
|
|
/**
|
|
* Set up click and touch listeners for the playback element
|
|
*
|
|
* On desktops, a click on the video itself will toggle playback,
|
|
* on a mobile device a click on the video toggles controls.
|
|
* (toggling controls is done by toggling the user state between active and
|
|
* inactive)
|
|
* A tap can signal that a user has become active, or has become inactive
|
|
* e.g. a quick tap on an iPhone movie should reveal the controls. Another
|
|
* quick tap should hide them again (signaling the user is in an inactive
|
|
* viewing state)
|
|
* In addition to this, we still want the user to be considered inactive after
|
|
* a few seconds of inactivity.
|
|
* Note: the only part of iOS interaction we can't mimic with this setup
|
|
* is a touch and hold on the video element counting as activity in order to
|
|
* keep the controls showing, but that shouldn't be an issue. A touch and hold
|
|
* on any controls will still keep the user active
|
|
*
|
|
* @private
|
|
* @method addTechControlsListeners_
|
|
*/
|
|
|
|
Player.prototype.addTechControlsListeners_ = function addTechControlsListeners_() {
|
|
// Make sure to remove all the previous listeners in case we are called multiple times.
|
|
this.removeTechControlsListeners_();
|
|
|
|
// Some browsers (Chrome & IE) don't trigger a click on a flash swf, but do
|
|
// trigger mousedown/up.
|
|
// http://stackoverflow.com/questions/1444562/javascript-onclick-event-over-flash-object
|
|
// Any touch events are set to block the mousedown event from happening
|
|
this.on(this.tech_, 'mousedown', this.handleTechClick_);
|
|
|
|
// If the controls were hidden we don't want that to change without a tap event
|
|
// so we'll check if the controls were already showing before reporting user
|
|
// activity
|
|
this.on(this.tech_, 'touchstart', this.handleTechTouchStart_);
|
|
this.on(this.tech_, 'touchmove', this.handleTechTouchMove_);
|
|
this.on(this.tech_, 'touchend', this.handleTechTouchEnd_);
|
|
|
|
// The tap listener needs to come after the touchend listener because the tap
|
|
// listener cancels out any reportedUserActivity when setting userActive(false)
|
|
this.on(this.tech_, 'tap', this.handleTechTap_);
|
|
};
|
|
|
|
/**
|
|
* Remove the listeners used for click and tap controls. This is needed for
|
|
* toggling to controls disabled, where a tap/touch should do nothing.
|
|
*
|
|
* @method removeTechControlsListeners_
|
|
* @private
|
|
*/
|
|
|
|
Player.prototype.removeTechControlsListeners_ = function removeTechControlsListeners_() {
|
|
// We don't want to just use `this.off()` because there might be other needed
|
|
// listeners added by techs that extend this.
|
|
this.off(this.tech_, 'tap', this.handleTechTap_);
|
|
this.off(this.tech_, 'touchstart', this.handleTechTouchStart_);
|
|
this.off(this.tech_, 'touchmove', this.handleTechTouchMove_);
|
|
this.off(this.tech_, 'touchend', this.handleTechTouchEnd_);
|
|
this.off(this.tech_, 'mousedown', this.handleTechClick_);
|
|
};
|
|
|
|
/**
|
|
* Player waits for the tech to be ready
|
|
*
|
|
* @method handleTechReady_
|
|
* @private
|
|
*/
|
|
|
|
Player.prototype.handleTechReady_ = function handleTechReady_() {
|
|
this.triggerReady();
|
|
|
|
// Keep the same volume as before
|
|
if (this.cache_.volume) {
|
|
this.techCall_('setVolume', this.cache_.volume);
|
|
}
|
|
|
|
// Look if the tech found a higher resolution poster while loading
|
|
this.handleTechPosterChange_();
|
|
|
|
// Update the duration if available
|
|
this.handleTechDurationChange_();
|
|
|
|
// Chrome and Safari both have issues with autoplay.
|
|
// In Safari (5.1.1), when we move the video element into the container div, autoplay doesn't work.
|
|
// In Chrome (15), if you have autoplay + a poster + no controls, the video gets hidden (but audio plays)
|
|
// This fixes both issues. Need to wait for API, so it updates displays correctly
|
|
if (this.src() && this.tag && this.options_.autoplay && this.paused()) {
|
|
delete this.tag.poster; // Chrome Fix. Fixed in Chrome v16.
|
|
this.play();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Fired when the user agent begins looking for media data
|
|
*
|
|
* @private
|
|
* @method handleTechLoadStart_
|
|
*/
|
|
|
|
Player.prototype.handleTechLoadStart_ = function handleTechLoadStart_() {
|
|
// TODO: Update to use `emptied` event instead. See #1277.
|
|
|
|
this.removeClass('vjs-ended');
|
|
|
|
// reset the error state
|
|
this.error(null);
|
|
|
|
// If it's already playing we want to trigger a firstplay event now.
|
|
// The firstplay event relies on both the play and loadstart events
|
|
// which can happen in any order for a new source
|
|
if (!this.paused()) {
|
|
this.trigger('loadstart');
|
|
this.trigger('firstplay');
|
|
} else {
|
|
// reset the hasStarted state
|
|
this.hasStarted(false);
|
|
this.trigger('loadstart');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add/remove the vjs-has-started class
|
|
*
|
|
* @param {Boolean} hasStarted The value of true adds the class the value of false remove the class
|
|
* @return {Boolean} Boolean value if has started
|
|
* @private
|
|
* @method hasStarted
|
|
*/
|
|
|
|
Player.prototype.hasStarted = function hasStarted(_hasStarted) {
|
|
if (_hasStarted !== undefined) {
|
|
// only update if this is a new value
|
|
if (this.hasStarted_ !== _hasStarted) {
|
|
this.hasStarted_ = _hasStarted;
|
|
if (_hasStarted) {
|
|
this.addClass('vjs-has-started');
|
|
// trigger the firstplay event if this newly has played
|
|
this.trigger('firstplay');
|
|
} else {
|
|
this.removeClass('vjs-has-started');
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
return !!this.hasStarted_;
|
|
};
|
|
|
|
/**
|
|
* Fired whenever the media begins or resumes playback
|
|
*
|
|
* @private
|
|
* @method handleTechPlay_
|
|
*/
|
|
|
|
Player.prototype.handleTechPlay_ = function handleTechPlay_() {
|
|
this.removeClass('vjs-ended');
|
|
this.removeClass('vjs-paused');
|
|
this.addClass('vjs-playing');
|
|
|
|
// hide the poster when the user hits play
|
|
// https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-play
|
|
this.hasStarted(true);
|
|
|
|
this.trigger('play');
|
|
};
|
|
|
|
/**
|
|
* Fired whenever the media begins waiting
|
|
*
|
|
* @private
|
|
* @method handleTechWaiting_
|
|
*/
|
|
|
|
Player.prototype.handleTechWaiting_ = function handleTechWaiting_() {
|
|
var _this2 = this;
|
|
|
|
this.addClass('vjs-waiting');
|
|
this.trigger('waiting');
|
|
this.one('timeupdate', function () {
|
|
return _this2.removeClass('vjs-waiting');
|
|
});
|
|
};
|
|
|
|
/**
|
|
* A handler for events that signal that waiting has ended
|
|
* which is not consistent between browsers. See #1351
|
|
*
|
|
* @private
|
|
* @method handleTechCanPlay_
|
|
*/
|
|
|
|
Player.prototype.handleTechCanPlay_ = function handleTechCanPlay_() {
|
|
this.removeClass('vjs-waiting');
|
|
this.trigger('canplay');
|
|
};
|
|
|
|
/**
|
|
* A handler for events that signal that waiting has ended
|
|
* which is not consistent between browsers. See #1351
|
|
*
|
|
* @private
|
|
* @method handleTechCanPlayThrough_
|
|
*/
|
|
|
|
Player.prototype.handleTechCanPlayThrough_ = function handleTechCanPlayThrough_() {
|
|
this.removeClass('vjs-waiting');
|
|
this.trigger('canplaythrough');
|
|
};
|
|
|
|
/**
|
|
* A handler for events that signal that waiting has ended
|
|
* which is not consistent between browsers. See #1351
|
|
*
|
|
* @private
|
|
* @method handleTechPlaying_
|
|
*/
|
|
|
|
Player.prototype.handleTechPlaying_ = function handleTechPlaying_() {
|
|
this.removeClass('vjs-waiting');
|
|
this.trigger('playing');
|
|
};
|
|
|
|
/**
|
|
* Fired whenever the player is jumping to a new time
|
|
*
|
|
* @private
|
|
* @method handleTechSeeking_
|
|
*/
|
|
|
|
Player.prototype.handleTechSeeking_ = function handleTechSeeking_() {
|
|
this.addClass('vjs-seeking');
|
|
this.trigger('seeking');
|
|
};
|
|
|
|
/**
|
|
* Fired when the player has finished jumping to a new time
|
|
*
|
|
* @private
|
|
* @method handleTechSeeked_
|
|
*/
|
|
|
|
Player.prototype.handleTechSeeked_ = function handleTechSeeked_() {
|
|
this.removeClass('vjs-seeking');
|
|
this.trigger('seeked');
|
|
};
|
|
|
|
/**
|
|
* Fired the first time a video is played
|
|
* Not part of the HLS spec, and we're not sure if this is the best
|
|
* implementation yet, so use sparingly. If you don't have a reason to
|
|
* prevent playback, use `myPlayer.one('play');` instead.
|
|
*
|
|
* @private
|
|
* @method handleTechFirstPlay_
|
|
*/
|
|
|
|
Player.prototype.handleTechFirstPlay_ = function handleTechFirstPlay_() {
|
|
//If the first starttime attribute is specified
|
|
//then we will start at the given offset in seconds
|
|
if (this.options_.starttime) {
|
|
this.currentTime(this.options_.starttime);
|
|
}
|
|
|
|
this.addClass('vjs-has-started');
|
|
this.trigger('firstplay');
|
|
};
|
|
|
|
/**
|
|
* Fired whenever the media has been paused
|
|
*
|
|
* @private
|
|
* @method handleTechPause_
|
|
*/
|
|
|
|
Player.prototype.handleTechPause_ = function handleTechPause_() {
|
|
this.removeClass('vjs-playing');
|
|
this.addClass('vjs-paused');
|
|
this.trigger('pause');
|
|
};
|
|
|
|
/**
|
|
* Fired while the user agent is downloading media data
|
|
*
|
|
* @private
|
|
* @method handleTechProgress_
|
|
*/
|
|
|
|
Player.prototype.handleTechProgress_ = function handleTechProgress_() {
|
|
this.trigger('progress');
|
|
};
|
|
|
|
/**
|
|
* Fired when the end of the media resource is reached (currentTime == duration)
|
|
*
|
|
* @private
|
|
* @method handleTechEnded_
|
|
*/
|
|
|
|
Player.prototype.handleTechEnded_ = function handleTechEnded_() {
|
|
this.addClass('vjs-ended');
|
|
if (this.options_.loop) {
|
|
this.currentTime(0);
|
|
this.play();
|
|
} else if (!this.paused()) {
|
|
this.pause();
|
|
}
|
|
|
|
this.trigger('ended');
|
|
};
|
|
|
|
/**
|
|
* Fired when the duration of the media resource is first known or changed
|
|
*
|
|
* @private
|
|
* @method handleTechDurationChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechDurationChange_ = function handleTechDurationChange_() {
|
|
this.duration(this.techGet_('duration'));
|
|
};
|
|
|
|
/**
|
|
* Handle a click on the media element to play/pause
|
|
*
|
|
* @param {Object=} event Event object
|
|
* @private
|
|
* @method handleTechClick_
|
|
*/
|
|
|
|
Player.prototype.handleTechClick_ = function handleTechClick_(event) {
|
|
// We're using mousedown to detect clicks thanks to Flash, but mousedown
|
|
// will also be triggered with right-clicks, so we need to prevent that
|
|
if (event.button !== 0) return;
|
|
|
|
// When controls are disabled a click should not toggle playback because
|
|
// the click is considered a control
|
|
if (this.controls()) {
|
|
if (this.paused()) {
|
|
this.play();
|
|
} else {
|
|
this.pause();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle a tap on the media element. It will toggle the user
|
|
* activity state, which hides and shows the controls.
|
|
*
|
|
* @private
|
|
* @method handleTechTap_
|
|
*/
|
|
|
|
Player.prototype.handleTechTap_ = function handleTechTap_() {
|
|
this.userActive(!this.userActive());
|
|
};
|
|
|
|
/**
|
|
* Handle touch to start
|
|
*
|
|
* @private
|
|
* @method handleTechTouchStart_
|
|
*/
|
|
|
|
Player.prototype.handleTechTouchStart_ = function handleTechTouchStart_() {
|
|
this.userWasActive = this.userActive();
|
|
};
|
|
|
|
/**
|
|
* Handle touch to move
|
|
*
|
|
* @private
|
|
* @method handleTechTouchMove_
|
|
*/
|
|
|
|
Player.prototype.handleTechTouchMove_ = function handleTechTouchMove_() {
|
|
if (this.userWasActive) {
|
|
this.reportUserActivity();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle touch to end
|
|
*
|
|
* @private
|
|
* @method handleTechTouchEnd_
|
|
*/
|
|
|
|
Player.prototype.handleTechTouchEnd_ = function handleTechTouchEnd_(event) {
|
|
// Stop the mouse events from also happening
|
|
event.preventDefault();
|
|
};
|
|
|
|
/**
|
|
* Fired when the player switches in or out of fullscreen mode
|
|
*
|
|
* @private
|
|
* @method handleFullscreenChange_
|
|
*/
|
|
|
|
Player.prototype.handleFullscreenChange_ = function handleFullscreenChange_() {
|
|
if (this.isFullscreen()) {
|
|
this.addClass('vjs-fullscreen');
|
|
} else {
|
|
this.removeClass('vjs-fullscreen');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* native click events on the SWF aren't triggered on IE11, Win8.1RT
|
|
* use stageclick events triggered from inside the SWF instead
|
|
*
|
|
* @private
|
|
* @method handleStageClick_
|
|
*/
|
|
|
|
Player.prototype.handleStageClick_ = function handleStageClick_() {
|
|
this.reportUserActivity();
|
|
};
|
|
|
|
/**
|
|
* Handle Tech Fullscreen Change
|
|
*
|
|
* @private
|
|
* @method handleTechFullscreenChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechFullscreenChange_ = function handleTechFullscreenChange_(event, data) {
|
|
if (data) {
|
|
this.isFullscreen(data.isFullscreen);
|
|
}
|
|
this.trigger('fullscreenchange');
|
|
};
|
|
|
|
/**
|
|
* Fires when an error occurred during the loading of an audio/video
|
|
*
|
|
* @private
|
|
* @method handleTechError_
|
|
*/
|
|
|
|
Player.prototype.handleTechError_ = function handleTechError_() {
|
|
var error = this.tech_.error();
|
|
this.error(error && error.code);
|
|
};
|
|
|
|
/**
|
|
* Fires when the browser is intentionally not getting media data
|
|
*
|
|
* @private
|
|
* @method handleTechSuspend_
|
|
*/
|
|
|
|
Player.prototype.handleTechSuspend_ = function handleTechSuspend_() {
|
|
this.trigger('suspend');
|
|
};
|
|
|
|
/**
|
|
* Fires when the loading of an audio/video is aborted
|
|
*
|
|
* @private
|
|
* @method handleTechAbort_
|
|
*/
|
|
|
|
Player.prototype.handleTechAbort_ = function handleTechAbort_() {
|
|
this.trigger('abort');
|
|
};
|
|
|
|
/**
|
|
* Fires when the current playlist is empty
|
|
*
|
|
* @private
|
|
* @method handleTechEmptied_
|
|
*/
|
|
|
|
Player.prototype.handleTechEmptied_ = function handleTechEmptied_() {
|
|
this.trigger('emptied');
|
|
};
|
|
|
|
/**
|
|
* Fires when the browser is trying to get media data, but data is not available
|
|
*
|
|
* @private
|
|
* @method handleTechStalled_
|
|
*/
|
|
|
|
Player.prototype.handleTechStalled_ = function handleTechStalled_() {
|
|
this.trigger('stalled');
|
|
};
|
|
|
|
/**
|
|
* Fires when the browser has loaded meta data for the audio/video
|
|
*
|
|
* @private
|
|
* @method handleTechLoadedMetaData_
|
|
*/
|
|
|
|
Player.prototype.handleTechLoadedMetaData_ = function handleTechLoadedMetaData_() {
|
|
this.trigger('loadedmetadata');
|
|
};
|
|
|
|
/**
|
|
* Fires when the browser has loaded the current frame of the audio/video
|
|
*
|
|
* @private
|
|
* @method handleTechLoadedData_
|
|
*/
|
|
|
|
Player.prototype.handleTechLoadedData_ = function handleTechLoadedData_() {
|
|
this.trigger('loadeddata');
|
|
};
|
|
|
|
/**
|
|
* Fires when the current playback position has changed
|
|
*
|
|
* @private
|
|
* @method handleTechTimeUpdate_
|
|
*/
|
|
|
|
Player.prototype.handleTechTimeUpdate_ = function handleTechTimeUpdate_() {
|
|
this.trigger('timeupdate');
|
|
};
|
|
|
|
/**
|
|
* Fires when the playing speed of the audio/video is changed
|
|
*
|
|
* @private
|
|
* @method handleTechRateChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechRateChange_ = function handleTechRateChange_() {
|
|
this.trigger('ratechange');
|
|
};
|
|
|
|
/**
|
|
* Fires when the volume has been changed
|
|
*
|
|
* @private
|
|
* @method handleTechVolumeChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechVolumeChange_ = function handleTechVolumeChange_() {
|
|
this.trigger('volumechange');
|
|
};
|
|
|
|
/**
|
|
* Fires when the text track has been changed
|
|
*
|
|
* @private
|
|
* @method handleTechTextTrackChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechTextTrackChange_ = function handleTechTextTrackChange_() {
|
|
this.trigger('texttrackchange');
|
|
};
|
|
|
|
/**
|
|
* Get object for cached values.
|
|
*
|
|
* @return {Object}
|
|
* @method getCache
|
|
*/
|
|
|
|
Player.prototype.getCache = function getCache() {
|
|
return this.cache_;
|
|
};
|
|
|
|
/**
|
|
* Pass values to the playback tech
|
|
*
|
|
* @param {String=} method Method
|
|
* @param {Object=} arg Argument
|
|
* @private
|
|
* @method techCall_
|
|
*/
|
|
|
|
Player.prototype.techCall_ = function techCall_(method, arg) {
|
|
// If it's not ready yet, call method when it is
|
|
if (this.tech_ && !this.tech_.isReady_) {
|
|
this.tech_.ready(function () {
|
|
this[method](arg);
|
|
}, true);
|
|
|
|
// Otherwise call method now
|
|
} else {
|
|
try {
|
|
this.tech_[method](arg);
|
|
} catch (e) {
|
|
_utilsLogJs2['default'](e);
|
|
throw e;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get calls can't wait for the tech, and sometimes don't need to.
|
|
*
|
|
* @param {String} method Tech method
|
|
* @return {Method}
|
|
* @private
|
|
* @method techGet_
|
|
*/
|
|
|
|
Player.prototype.techGet_ = function techGet_(method) {
|
|
if (this.tech_ && this.tech_.isReady_) {
|
|
|
|
// Flash likes to die and reload when you hide or reposition it.
|
|
// In these cases the object methods go away and we get errors.
|
|
// When that happens we'll catch the errors and inform tech that it's not ready any more.
|
|
try {
|
|
return this.tech_[method]();
|
|
} catch (e) {
|
|
// When building additional tech libs, an expected method may not be defined yet
|
|
if (this.tech_[method] === undefined) {
|
|
_utilsLogJs2['default']('Video.js: ' + method + ' method not defined for ' + this.techName_ + ' playback technology.', e);
|
|
} else {
|
|
// When a method isn't available on the object it throws a TypeError
|
|
if (e.name === 'TypeError') {
|
|
_utilsLogJs2['default']('Video.js: ' + method + ' unavailable on ' + this.techName_ + ' playback technology element.', e);
|
|
this.tech_.isReady_ = false;
|
|
} else {
|
|
_utilsLogJs2['default'](e);
|
|
}
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
return;
|
|
};
|
|
|
|
/**
|
|
* start media playback
|
|
* ```js
|
|
* myPlayer.play();
|
|
* ```
|
|
*
|
|
* @return {Player} self
|
|
* @method play
|
|
*/
|
|
|
|
Player.prototype.play = function play() {
|
|
this.techCall_('play');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Pause the video playback
|
|
* ```js
|
|
* myPlayer.pause();
|
|
* ```
|
|
*
|
|
* @return {Player} self
|
|
* @method pause
|
|
*/
|
|
|
|
Player.prototype.pause = function pause() {
|
|
this.techCall_('pause');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Check if the player is paused
|
|
* ```js
|
|
* var isPaused = myPlayer.paused();
|
|
* var isPlaying = !myPlayer.paused();
|
|
* ```
|
|
*
|
|
* @return {Boolean} false if the media is currently playing, or true otherwise
|
|
* @method paused
|
|
*/
|
|
|
|
Player.prototype.paused = function paused() {
|
|
// The initial state of paused should be true (in Safari it's actually false)
|
|
return this.techGet_('paused') === false ? false : true;
|
|
};
|
|
|
|
/**
|
|
* Returns whether or not the user is "scrubbing". Scrubbing is when the user
|
|
* has clicked the progress bar handle and is dragging it along the progress bar.
|
|
*
|
|
* @param {Boolean} isScrubbing True/false the user is scrubbing
|
|
* @return {Boolean} The scrubbing status when getting
|
|
* @return {Object} The player when setting
|
|
* @method scrubbing
|
|
*/
|
|
|
|
Player.prototype.scrubbing = function scrubbing(isScrubbing) {
|
|
if (isScrubbing !== undefined) {
|
|
this.scrubbing_ = !!isScrubbing;
|
|
|
|
if (isScrubbing) {
|
|
this.addClass('vjs-scrubbing');
|
|
} else {
|
|
this.removeClass('vjs-scrubbing');
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
return this.scrubbing_;
|
|
};
|
|
|
|
/**
|
|
* Get or set the current time (in seconds)
|
|
* ```js
|
|
* // get
|
|
* var whereYouAt = myPlayer.currentTime();
|
|
* // set
|
|
* myPlayer.currentTime(120); // 2 minutes into the video
|
|
* ```
|
|
*
|
|
* @param {Number|String=} seconds The time to seek to
|
|
* @return {Number} The time in seconds, when not setting
|
|
* @return {Player} self, when the current time is set
|
|
* @method currentTime
|
|
*/
|
|
|
|
Player.prototype.currentTime = function currentTime(seconds) {
|
|
if (seconds !== undefined) {
|
|
|
|
this.techCall_('setCurrentTime', seconds);
|
|
|
|
return this;
|
|
}
|
|
|
|
// cache last currentTime and return. default to 0 seconds
|
|
//
|
|
// Caching the currentTime is meant to prevent a massive amount of reads on the tech's
|
|
// currentTime when scrubbing, but may not provide much performance benefit afterall.
|
|
// Should be tested. Also something has to read the actual current time or the cache will
|
|
// never get updated.
|
|
return this.cache_.currentTime = this.techGet_('currentTime') || 0;
|
|
};
|
|
|
|
/**
|
|
* Get the length in time of the video in seconds
|
|
* ```js
|
|
* var lengthOfVideo = myPlayer.duration();
|
|
* ```
|
|
* **NOTE**: The video must have started loading before the duration can be
|
|
* known, and in the case of Flash, may not be known until the video starts
|
|
* playing.
|
|
*
|
|
* @param {Number} seconds Duration when setting
|
|
* @return {Number} The duration of the video in seconds when getting
|
|
* @method duration
|
|
*/
|
|
|
|
Player.prototype.duration = function duration(seconds) {
|
|
if (seconds === undefined) {
|
|
return this.cache_.duration || 0;
|
|
}
|
|
|
|
seconds = parseFloat(seconds) || 0;
|
|
|
|
// Standardize on Inifity for signaling video is live
|
|
if (seconds < 0) {
|
|
seconds = Infinity;
|
|
}
|
|
|
|
if (seconds !== this.cache_.duration) {
|
|
// Cache the last set value for optimized scrubbing (esp. Flash)
|
|
this.cache_.duration = seconds;
|
|
|
|
if (seconds === Infinity) {
|
|
this.addClass('vjs-live');
|
|
} else {
|
|
this.removeClass('vjs-live');
|
|
}
|
|
|
|
this.trigger('durationchange');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Calculates how much time is left.
|
|
* ```js
|
|
* var timeLeft = myPlayer.remainingTime();
|
|
* ```
|
|
* Not a native video element function, but useful
|
|
*
|
|
* @return {Number} The time remaining in seconds
|
|
* @method remainingTime
|
|
*/
|
|
|
|
Player.prototype.remainingTime = function remainingTime() {
|
|
return this.duration() - this.currentTime();
|
|
};
|
|
|
|
// http://dev.w3.org/html5/spec/video.html#dom-media-buffered
|
|
// Buffered returns a timerange object.
|
|
// Kind of like an array of portions of the video that have been downloaded.
|
|
|
|
/**
|
|
* Get a TimeRange object with the times of the video that have been downloaded
|
|
* If you just want the percent of the video that's been downloaded,
|
|
* use bufferedPercent.
|
|
* ```js
|
|
* // Number of different ranges of time have been buffered. Usually 1.
|
|
* numberOfRanges = bufferedTimeRange.length,
|
|
* // Time in seconds when the first range starts. Usually 0.
|
|
* firstRangeStart = bufferedTimeRange.start(0),
|
|
* // Time in seconds when the first range ends
|
|
* firstRangeEnd = bufferedTimeRange.end(0),
|
|
* // Length in seconds of the first time range
|
|
* firstRangeLength = firstRangeEnd - firstRangeStart;
|
|
* ```
|
|
*
|
|
* @return {Object} A mock TimeRange object (following HTML spec)
|
|
* @method buffered
|
|
*/
|
|
|
|
Player.prototype.buffered = function buffered() {
|
|
var buffered = this.techGet_('buffered');
|
|
|
|
if (!buffered || !buffered.length) {
|
|
buffered = _utilsTimeRangesJs.createTimeRange(0, 0);
|
|
}
|
|
|
|
return buffered;
|
|
};
|
|
|
|
/**
|
|
* Get the percent (as a decimal) of the video that's been downloaded
|
|
* ```js
|
|
* var howMuchIsDownloaded = myPlayer.bufferedPercent();
|
|
* ```
|
|
* 0 means none, 1 means all.
|
|
* (This method isn't in the HTML5 spec, but it's very convenient)
|
|
*
|
|
* @return {Number} A decimal between 0 and 1 representing the percent
|
|
* @method bufferedPercent
|
|
*/
|
|
|
|
Player.prototype.bufferedPercent = function bufferedPercent() {
|
|
return _utilsBufferJs.bufferedPercent(this.buffered(), this.duration());
|
|
};
|
|
|
|
/**
|
|
* Get the ending time of the last buffered time range
|
|
* This is used in the progress bar to encapsulate all time ranges.
|
|
*
|
|
* @return {Number} The end of the last buffered time range
|
|
* @method bufferedEnd
|
|
*/
|
|
|
|
Player.prototype.bufferedEnd = function bufferedEnd() {
|
|
var buffered = this.buffered(),
|
|
duration = this.duration(),
|
|
end = buffered.end(buffered.length - 1);
|
|
|
|
if (end > duration) {
|
|
end = duration;
|
|
}
|
|
|
|
return end;
|
|
};
|
|
|
|
/**
|
|
* Get or set the current volume of the media
|
|
* ```js
|
|
* // get
|
|
* var howLoudIsIt = myPlayer.volume();
|
|
* // set
|
|
* myPlayer.volume(0.5); // Set volume to half
|
|
* ```
|
|
* 0 is off (muted), 1.0 is all the way up, 0.5 is half way.
|
|
*
|
|
* @param {Number} percentAsDecimal The new volume as a decimal percent
|
|
* @return {Number} The current volume when getting
|
|
* @return {Player} self when setting
|
|
* @method volume
|
|
*/
|
|
|
|
Player.prototype.volume = function volume(percentAsDecimal) {
|
|
var vol = undefined;
|
|
|
|
if (percentAsDecimal !== undefined) {
|
|
vol = Math.max(0, Math.min(1, parseFloat(percentAsDecimal))); // Force value to between 0 and 1
|
|
this.cache_.volume = vol;
|
|
this.techCall_('setVolume', vol);
|
|
|
|
return this;
|
|
}
|
|
|
|
// Default to 1 when returning current volume.
|
|
vol = parseFloat(this.techGet_('volume'));
|
|
return isNaN(vol) ? 1 : vol;
|
|
};
|
|
|
|
/**
|
|
* Get the current muted state, or turn mute on or off
|
|
* ```js
|
|
* // get
|
|
* var isVolumeMuted = myPlayer.muted();
|
|
* // set
|
|
* myPlayer.muted(true); // mute the volume
|
|
* ```
|
|
*
|
|
* @param {Boolean=} muted True to mute, false to unmute
|
|
* @return {Boolean} True if mute is on, false if not when getting
|
|
* @return {Player} self when setting mute
|
|
* @method muted
|
|
*/
|
|
|
|
Player.prototype.muted = function muted(_muted) {
|
|
if (_muted !== undefined) {
|
|
this.techCall_('setMuted', _muted);
|
|
return this;
|
|
}
|
|
return this.techGet_('muted') || false; // Default to false
|
|
};
|
|
|
|
// Check if current tech can support native fullscreen
|
|
// (e.g. with built in controls like iOS, so not our flash swf)
|
|
/**
|
|
* Check to see if fullscreen is supported
|
|
*
|
|
* @return {Boolean}
|
|
* @method supportsFullScreen
|
|
*/
|
|
|
|
Player.prototype.supportsFullScreen = function supportsFullScreen() {
|
|
return this.techGet_('supportsFullScreen') || false;
|
|
};
|
|
|
|
/**
|
|
* Check if the player is in fullscreen mode
|
|
* ```js
|
|
* // get
|
|
* var fullscreenOrNot = myPlayer.isFullscreen();
|
|
* // set
|
|
* myPlayer.isFullscreen(true); // tell the player it's in fullscreen
|
|
* ```
|
|
* NOTE: As of the latest HTML5 spec, isFullscreen is no longer an official
|
|
* property and instead document.fullscreenElement is used. But isFullscreen is
|
|
* still a valuable property for internal player workings.
|
|
*
|
|
* @param {Boolean=} isFS Update the player's fullscreen state
|
|
* @return {Boolean} true if fullscreen false if not when getting
|
|
* @return {Player} self when setting
|
|
* @method isFullscreen
|
|
*/
|
|
|
|
Player.prototype.isFullscreen = function isFullscreen(isFS) {
|
|
if (isFS !== undefined) {
|
|
this.isFullscreen_ = !!isFS;
|
|
return this;
|
|
}
|
|
return !!this.isFullscreen_;
|
|
};
|
|
|
|
/**
|
|
* Increase the size of the video to full screen
|
|
* ```js
|
|
* myPlayer.requestFullscreen();
|
|
* ```
|
|
* In some browsers, full screen is not supported natively, so it enters
|
|
* "full window mode", where the video fills the browser window.
|
|
* In browsers and devices that support native full screen, sometimes the
|
|
* browser's default controls will be shown, and not the Video.js custom skin.
|
|
* This includes most mobile devices (iOS, Android) and older versions of
|
|
* Safari.
|
|
*
|
|
* @return {Player} self
|
|
* @method requestFullscreen
|
|
*/
|
|
|
|
Player.prototype.requestFullscreen = function requestFullscreen() {
|
|
var fsApi = _fullscreenApiJs2['default'];
|
|
|
|
this.isFullscreen(true);
|
|
|
|
if (fsApi.requestFullscreen) {
|
|
// the browser supports going fullscreen at the element level so we can
|
|
// take the controls fullscreen as well as the video
|
|
|
|
// Trigger fullscreenchange event after change
|
|
// We have to specifically add this each time, and remove
|
|
// when canceling fullscreen. Otherwise if there's multiple
|
|
// players on a page, they would all be reacting to the same fullscreen
|
|
// events
|
|
Events.on(_globalDocument2['default'], fsApi.fullscreenchange, Fn.bind(this, function documentFullscreenChange(e) {
|
|
this.isFullscreen(_globalDocument2['default'][fsApi.fullscreenElement]);
|
|
|
|
// If cancelling fullscreen, remove event listener.
|
|
if (this.isFullscreen() === false) {
|
|
Events.off(_globalDocument2['default'], fsApi.fullscreenchange, documentFullscreenChange);
|
|
}
|
|
|
|
this.trigger('fullscreenchange');
|
|
}));
|
|
|
|
this.el_[fsApi.requestFullscreen]();
|
|
} else if (this.tech_.supportsFullScreen()) {
|
|
// we can't take the video.js controls fullscreen but we can go fullscreen
|
|
// with native controls
|
|
this.techCall_('enterFullScreen');
|
|
} else {
|
|
// fullscreen isn't supported so we'll just stretch the video element to
|
|
// fill the viewport
|
|
this.enterFullWindow();
|
|
this.trigger('fullscreenchange');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return the video to its normal size after having been in full screen mode
|
|
* ```js
|
|
* myPlayer.exitFullscreen();
|
|
* ```
|
|
*
|
|
* @return {Player} self
|
|
* @method exitFullscreen
|
|
*/
|
|
|
|
Player.prototype.exitFullscreen = function exitFullscreen() {
|
|
var fsApi = _fullscreenApiJs2['default'];
|
|
this.isFullscreen(false);
|
|
|
|
// Check for browser element fullscreen support
|
|
if (fsApi.requestFullscreen) {
|
|
_globalDocument2['default'][fsApi.exitFullscreen]();
|
|
} else if (this.tech_.supportsFullScreen()) {
|
|
this.techCall_('exitFullScreen');
|
|
} else {
|
|
this.exitFullWindow();
|
|
this.trigger('fullscreenchange');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* When fullscreen isn't supported we can stretch the video container to as wide as the browser will let us.
|
|
*
|
|
* @method enterFullWindow
|
|
*/
|
|
|
|
Player.prototype.enterFullWindow = function enterFullWindow() {
|
|
this.isFullWindow = true;
|
|
|
|
// Storing original doc overflow value to return to when fullscreen is off
|
|
this.docOrigOverflow = _globalDocument2['default'].documentElement.style.overflow;
|
|
|
|
// Add listener for esc key to exit fullscreen
|
|
Events.on(_globalDocument2['default'], 'keydown', Fn.bind(this, this.fullWindowOnEscKey));
|
|
|
|
// Hide any scroll bars
|
|
_globalDocument2['default'].documentElement.style.overflow = 'hidden';
|
|
|
|
// Apply fullscreen styles
|
|
Dom.addElClass(_globalDocument2['default'].body, 'vjs-full-window');
|
|
|
|
this.trigger('enterFullWindow');
|
|
};
|
|
|
|
/**
|
|
* Check for call to either exit full window or full screen on ESC key
|
|
*
|
|
* @param {String} event Event to check for key press
|
|
* @method fullWindowOnEscKey
|
|
*/
|
|
|
|
Player.prototype.fullWindowOnEscKey = function fullWindowOnEscKey(event) {
|
|
if (event.keyCode === 27) {
|
|
if (this.isFullscreen() === true) {
|
|
this.exitFullscreen();
|
|
} else {
|
|
this.exitFullWindow();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Exit full window
|
|
*
|
|
* @method exitFullWindow
|
|
*/
|
|
|
|
Player.prototype.exitFullWindow = function exitFullWindow() {
|
|
this.isFullWindow = false;
|
|
Events.off(_globalDocument2['default'], 'keydown', this.fullWindowOnEscKey);
|
|
|
|
// Unhide scroll bars.
|
|
_globalDocument2['default'].documentElement.style.overflow = this.docOrigOverflow;
|
|
|
|
// Remove fullscreen styles
|
|
Dom.removeElClass(_globalDocument2['default'].body, 'vjs-full-window');
|
|
|
|
// Resize the box, controller, and poster to original sizes
|
|
// this.positionAll();
|
|
this.trigger('exitFullWindow');
|
|
};
|
|
|
|
/**
|
|
* Check whether the player can play a given mimetype
|
|
*
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
* @method canPlayType
|
|
*/
|
|
|
|
Player.prototype.canPlayType = function canPlayType(type) {
|
|
var can = undefined;
|
|
|
|
// Loop through each playback technology in the options order
|
|
for (var i = 0, j = this.options_.techOrder; i < j.length; i++) {
|
|
var techName = _utilsToTitleCaseJs2['default'](j[i]);
|
|
var tech = _techTechJs2['default'].getTech(techName);
|
|
|
|
// Support old behavior of techs being registered as components.
|
|
// Remove once that deprecated behavior is removed.
|
|
if (!tech) {
|
|
tech = _componentJs2['default'].getComponent(techName);
|
|
}
|
|
|
|
// Check if the current tech is defined before continuing
|
|
if (!tech) {
|
|
_utilsLogJs2['default'].error('The "' + techName + '" tech is undefined. Skipped browser support check for that tech.');
|
|
continue;
|
|
}
|
|
|
|
// Check if the browser supports this technology
|
|
if (tech.isSupported()) {
|
|
can = tech.canPlayType(type);
|
|
|
|
if (can) {
|
|
return can;
|
|
}
|
|
}
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Select source based on tech-order or source-order
|
|
* Uses source-order selection if `options.sourceOrder` is truthy. Otherwise,
|
|
* defaults to tech-order selection
|
|
*
|
|
* @param {Array} sources The sources for a media asset
|
|
* @return {Object|Boolean} Object of source and tech order, otherwise false
|
|
* @method selectSource
|
|
*/
|
|
|
|
Player.prototype.selectSource = function selectSource(sources) {
|
|
// Get only the techs specified in `techOrder` that exist and are supported by the
|
|
// current platform
|
|
var techs = this.options_.techOrder.map(_utilsToTitleCaseJs2['default']).map(function (techName) {
|
|
// `Component.getComponent(...)` is for support of old behavior of techs
|
|
// being registered as components.
|
|
// Remove once that deprecated behavior is removed.
|
|
return [techName, _techTechJs2['default'].getTech(techName) || _componentJs2['default'].getComponent(techName)];
|
|
}).filter(function (_ref) {
|
|
var techName = _ref[0];
|
|
var tech = _ref[1];
|
|
|
|
// Check if the current tech is defined before continuing
|
|
if (tech) {
|
|
// Check if the browser supports this technology
|
|
return tech.isSupported();
|
|
}
|
|
|
|
_utilsLogJs2['default'].error('The "' + techName + '" tech is undefined. Skipped browser support check for that tech.');
|
|
return false;
|
|
});
|
|
|
|
// Iterate over each `innerArray` element once per `outerArray` element and execute
|
|
// `tester` with both. If `tester` returns a non-falsy value, exit early and return
|
|
// that value.
|
|
var findFirstPassingTechSourcePair = function findFirstPassingTechSourcePair(outerArray, innerArray, tester) {
|
|
var found = undefined;
|
|
|
|
outerArray.some(function (outerChoice) {
|
|
return innerArray.some(function (innerChoice) {
|
|
found = tester(outerChoice, innerChoice);
|
|
|
|
if (found) {
|
|
return true;
|
|
}
|
|
});
|
|
});
|
|
|
|
return found;
|
|
};
|
|
|
|
var foundSourceAndTech = undefined;
|
|
var flip = function flip(fn) {
|
|
return function (a, b) {
|
|
return fn(b, a);
|
|
};
|
|
};
|
|
var finder = function finder(_ref2, source) {
|
|
var techName = _ref2[0];
|
|
var tech = _ref2[1];
|
|
|
|
if (tech.canPlaySource(source)) {
|
|
return { source: source, tech: techName };
|
|
}
|
|
};
|
|
|
|
// Depending on the truthiness of `options.sourceOrder`, we swap the order of techs and sources
|
|
// to select from them based on their priority.
|
|
if (this.options_.sourceOrder) {
|
|
// Source-first ordering
|
|
foundSourceAndTech = findFirstPassingTechSourcePair(sources, techs, flip(finder));
|
|
} else {
|
|
// Tech-first ordering
|
|
foundSourceAndTech = findFirstPassingTechSourcePair(techs, sources, finder);
|
|
}
|
|
|
|
return foundSourceAndTech || false;
|
|
};
|
|
|
|
/**
|
|
* The source function updates the video source
|
|
* There are three types of variables you can pass as the argument.
|
|
* **URL String**: A URL to the the video file. Use this method if you are sure
|
|
* the current playback technology (HTML5/Flash) can support the source you
|
|
* provide. Currently only MP4 files can be used in both HTML5 and Flash.
|
|
* ```js
|
|
* myPlayer.src("http://www.example.com/path/to/video.mp4");
|
|
* ```
|
|
* **Source Object (or element):* * A javascript object containing information
|
|
* about the source file. Use this method if you want the player to determine if
|
|
* it can support the file using the type information.
|
|
* ```js
|
|
* myPlayer.src({ type: "video/mp4", src: "http://www.example.com/path/to/video.mp4" });
|
|
* ```
|
|
* **Array of Source Objects:* * To provide multiple versions of the source so
|
|
* that it can be played using HTML5 across browsers you can use an array of
|
|
* source objects. Video.js will detect which version is supported and load that
|
|
* file.
|
|
* ```js
|
|
* myPlayer.src([
|
|
* { type: "video/mp4", src: "http://www.example.com/path/to/video.mp4" },
|
|
* { type: "video/webm", src: "http://www.example.com/path/to/video.webm" },
|
|
* { type: "video/ogg", src: "http://www.example.com/path/to/video.ogv" }
|
|
* ]);
|
|
* ```
|
|
*
|
|
* @param {String|Object|Array=} source The source URL, object, or array of sources
|
|
* @return {String} The current video source when getting
|
|
* @return {String} The player when setting
|
|
* @method src
|
|
*/
|
|
|
|
Player.prototype.src = function src(source) {
|
|
if (source === undefined) {
|
|
return this.techGet_('src');
|
|
}
|
|
|
|
var currentTech = _techTechJs2['default'].getTech(this.techName_);
|
|
// Support old behavior of techs being registered as components.
|
|
// Remove once that deprecated behavior is removed.
|
|
if (!currentTech) {
|
|
currentTech = _componentJs2['default'].getComponent(this.techName_);
|
|
}
|
|
|
|
// case: Array of source objects to choose from and pick the best to play
|
|
if (Array.isArray(source)) {
|
|
this.sourceList_(source);
|
|
|
|
// case: URL String (http://myvideo...)
|
|
} else if (typeof source === 'string') {
|
|
// create a source object from the string
|
|
this.src({ src: source });
|
|
|
|
// case: Source object { src: '', type: '' ... }
|
|
} else if (source instanceof Object) {
|
|
// check if the source has a type and the loaded tech cannot play the source
|
|
// if there's no type we'll just try the current tech
|
|
if (source.type && !currentTech.canPlaySource(source)) {
|
|
// create a source list with the current source and send through
|
|
// the tech loop to check for a compatible technology
|
|
this.sourceList_([source]);
|
|
} else {
|
|
this.cache_.src = source.src;
|
|
this.currentType_ = source.type || '';
|
|
|
|
// wait until the tech is ready to set the source
|
|
this.ready(function () {
|
|
|
|
// The setSource tech method was added with source handlers
|
|
// so older techs won't support it
|
|
// We need to check the direct prototype for the case where subclasses
|
|
// of the tech do not support source handlers
|
|
if (currentTech.prototype.hasOwnProperty('setSource')) {
|
|
this.techCall_('setSource', source);
|
|
} else {
|
|
this.techCall_('src', source.src);
|
|
}
|
|
|
|
if (this.options_.preload === 'auto') {
|
|
this.load();
|
|
}
|
|
|
|
if (this.options_.autoplay) {
|
|
this.play();
|
|
}
|
|
|
|
// Set the source synchronously if possible (#2326)
|
|
}, true);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Handle an array of source objects
|
|
*
|
|
* @param {Array} sources Array of source objects
|
|
* @private
|
|
* @method sourceList_
|
|
*/
|
|
|
|
Player.prototype.sourceList_ = function sourceList_(sources) {
|
|
var sourceTech = this.selectSource(sources);
|
|
|
|
if (sourceTech) {
|
|
if (sourceTech.tech === this.techName_) {
|
|
// if this technology is already loaded, set the source
|
|
this.src(sourceTech.source);
|
|
} else {
|
|
// load this technology with the chosen source
|
|
this.loadTech_(sourceTech.tech, sourceTech.source);
|
|
}
|
|
} else {
|
|
// We need to wrap this in a timeout to give folks a chance to add error event handlers
|
|
this.setTimeout(function () {
|
|
this.error({ code: 4, message: this.localize(this.options_.notSupportedMessage) });
|
|
}, 0);
|
|
|
|
// we could not find an appropriate tech, but let's still notify the delegate that this is it
|
|
// this needs a better comment about why this is needed
|
|
this.triggerReady();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Begin loading the src data.
|
|
*
|
|
* @return {Player} Returns the player
|
|
* @method load
|
|
*/
|
|
|
|
Player.prototype.load = function load() {
|
|
this.techCall_('load');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Reset the player. Loads the first tech in the techOrder,
|
|
* and calls `reset` on the tech`.
|
|
*
|
|
* @return {Player} Returns the player
|
|
* @method reset
|
|
*/
|
|
|
|
Player.prototype.reset = function reset() {
|
|
this.loadTech_(_utilsToTitleCaseJs2['default'](this.options_.techOrder[0]), null);
|
|
this.techCall_('reset');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Returns the fully qualified URL of the current source value e.g. http://mysite.com/video.mp4
|
|
* Can be used in conjuction with `currentType` to assist in rebuilding the current source object.
|
|
*
|
|
* @return {String} The current source
|
|
* @method currentSrc
|
|
*/
|
|
|
|
Player.prototype.currentSrc = function currentSrc() {
|
|
return this.techGet_('currentSrc') || this.cache_.src || '';
|
|
};
|
|
|
|
/**
|
|
* Get the current source type e.g. video/mp4
|
|
* This can allow you rebuild the current source object so that you could load the same
|
|
* source and tech later
|
|
*
|
|
* @return {String} The source MIME type
|
|
* @method currentType
|
|
*/
|
|
|
|
Player.prototype.currentType = function currentType() {
|
|
return this.currentType_ || '';
|
|
};
|
|
|
|
/**
|
|
* Get or set the preload attribute
|
|
*
|
|
* @param {Boolean} value Boolean to determine if preload should be used
|
|
* @return {String} The preload attribute value when getting
|
|
* @return {Player} Returns the player when setting
|
|
* @method preload
|
|
*/
|
|
|
|
Player.prototype.preload = function preload(value) {
|
|
if (value !== undefined) {
|
|
this.techCall_('setPreload', value);
|
|
this.options_.preload = value;
|
|
return this;
|
|
}
|
|
return this.techGet_('preload');
|
|
};
|
|
|
|
/**
|
|
* Get or set the autoplay attribute.
|
|
*
|
|
* @param {Boolean} value Boolean to determine if video should autoplay
|
|
* @return {String} The autoplay attribute value when getting
|
|
* @return {Player} Returns the player when setting
|
|
* @method autoplay
|
|
*/
|
|
|
|
Player.prototype.autoplay = function autoplay(value) {
|
|
if (value !== undefined) {
|
|
this.techCall_('setAutoplay', value);
|
|
this.options_.autoplay = value;
|
|
return this;
|
|
}
|
|
return this.techGet_('autoplay', value);
|
|
};
|
|
|
|
/**
|
|
* Get or set the loop attribute on the video element.
|
|
*
|
|
* @param {Boolean} value Boolean to determine if video should loop
|
|
* @return {String} The loop attribute value when getting
|
|
* @return {Player} Returns the player when setting
|
|
* @method loop
|
|
*/
|
|
|
|
Player.prototype.loop = function loop(value) {
|
|
if (value !== undefined) {
|
|
this.techCall_('setLoop', value);
|
|
this.options_['loop'] = value;
|
|
return this;
|
|
}
|
|
return this.techGet_('loop');
|
|
};
|
|
|
|
/**
|
|
* Get or set the poster image source url
|
|
*
|
|
* ##### EXAMPLE:
|
|
* ```js
|
|
* // get
|
|
* var currentPoster = myPlayer.poster();
|
|
* // set
|
|
* myPlayer.poster('http://example.com/myImage.jpg');
|
|
* ```
|
|
*
|
|
* @param {String=} src Poster image source URL
|
|
* @return {String} poster URL when getting
|
|
* @return {Player} self when setting
|
|
* @method poster
|
|
*/
|
|
|
|
Player.prototype.poster = function poster(src) {
|
|
if (src === undefined) {
|
|
return this.poster_;
|
|
}
|
|
|
|
// The correct way to remove a poster is to set as an empty string
|
|
// other falsey values will throw errors
|
|
if (!src) {
|
|
src = '';
|
|
}
|
|
|
|
// update the internal poster variable
|
|
this.poster_ = src;
|
|
|
|
// update the tech's poster
|
|
this.techCall_('setPoster', src);
|
|
|
|
// alert components that the poster has been set
|
|
this.trigger('posterchange');
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Some techs (e.g. YouTube) can provide a poster source in an
|
|
* asynchronous way. We want the poster component to use this
|
|
* poster source so that it covers up the tech's controls.
|
|
* (YouTube's play button). However we only want to use this
|
|
* soruce if the player user hasn't set a poster through
|
|
* the normal APIs.
|
|
*
|
|
* @private
|
|
* @method handleTechPosterChange_
|
|
*/
|
|
|
|
Player.prototype.handleTechPosterChange_ = function handleTechPosterChange_() {
|
|
if (!this.poster_ && this.tech_ && this.tech_.poster) {
|
|
this.poster_ = this.tech_.poster() || '';
|
|
|
|
// Let components know the poster has changed
|
|
this.trigger('posterchange');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get or set whether or not the controls are showing.
|
|
*
|
|
* @param {Boolean} bool Set controls to showing or not
|
|
* @return {Boolean} Controls are showing
|
|
* @method controls
|
|
*/
|
|
|
|
Player.prototype.controls = function controls(bool) {
|
|
if (bool !== undefined) {
|
|
bool = !!bool; // force boolean
|
|
// Don't trigger a change event unless it actually changed
|
|
if (this.controls_ !== bool) {
|
|
this.controls_ = bool;
|
|
|
|
if (this.usingNativeControls()) {
|
|
this.techCall_('setControls', bool);
|
|
}
|
|
|
|
if (bool) {
|
|
this.removeClass('vjs-controls-disabled');
|
|
this.addClass('vjs-controls-enabled');
|
|
this.trigger('controlsenabled');
|
|
|
|
if (!this.usingNativeControls()) {
|
|
this.addTechControlsListeners_();
|
|
}
|
|
} else {
|
|
this.removeClass('vjs-controls-enabled');
|
|
this.addClass('vjs-controls-disabled');
|
|
this.trigger('controlsdisabled');
|
|
|
|
if (!this.usingNativeControls()) {
|
|
this.removeTechControlsListeners_();
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
return !!this.controls_;
|
|
};
|
|
|
|
/**
|
|
* Toggle native controls on/off. Native controls are the controls built into
|
|
* devices (e.g. default iPhone controls), Flash, or other techs
|
|
* (e.g. Vimeo Controls)
|
|
* **This should only be set by the current tech, because only the tech knows
|
|
* if it can support native controls**
|
|
*
|
|
* @param {Boolean} bool True signals that native controls are on
|
|
* @return {Player} Returns the player
|
|
* @private
|
|
* @method usingNativeControls
|
|
*/
|
|
|
|
Player.prototype.usingNativeControls = function usingNativeControls(bool) {
|
|
if (bool !== undefined) {
|
|
bool = !!bool; // force boolean
|
|
// Don't trigger a change event unless it actually changed
|
|
if (this.usingNativeControls_ !== bool) {
|
|
this.usingNativeControls_ = bool;
|
|
if (bool) {
|
|
this.addClass('vjs-using-native-controls');
|
|
|
|
/**
|
|
* player is using the native device controls
|
|
*
|
|
* @event usingnativecontrols
|
|
* @memberof Player
|
|
* @instance
|
|
* @private
|
|
*/
|
|
this.trigger('usingnativecontrols');
|
|
} else {
|
|
this.removeClass('vjs-using-native-controls');
|
|
|
|
/**
|
|
* player is using the custom HTML controls
|
|
*
|
|
* @event usingcustomcontrols
|
|
* @memberof Player
|
|
* @instance
|
|
* @private
|
|
*/
|
|
this.trigger('usingcustomcontrols');
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
return !!this.usingNativeControls_;
|
|
};
|
|
|
|
/**
|
|
* Set or get the current MediaError
|
|
*
|
|
* @param {*} err A MediaError or a String/Number to be turned into a MediaError
|
|
* @return {MediaError|null} when getting
|
|
* @return {Player} when setting
|
|
* @method error
|
|
*/
|
|
|
|
Player.prototype.error = function error(err) {
|
|
if (err === undefined) {
|
|
return this.error_ || null;
|
|
}
|
|
|
|
// restoring to default
|
|
if (err === null) {
|
|
this.error_ = err;
|
|
this.removeClass('vjs-error');
|
|
this.errorDisplay.close();
|
|
return this;
|
|
}
|
|
|
|
// error instance
|
|
if (err instanceof _mediaErrorJs2['default']) {
|
|
this.error_ = err;
|
|
} else {
|
|
this.error_ = new _mediaErrorJs2['default'](err);
|
|
}
|
|
|
|
// add the vjs-error classname to the player
|
|
this.addClass('vjs-error');
|
|
|
|
// log the name of the error type and any message
|
|
// ie8 just logs "[object object]" if you just log the error object
|
|
_utilsLogJs2['default'].error('(CODE:' + this.error_.code + ' ' + _mediaErrorJs2['default'].errorTypes[this.error_.code] + ')', this.error_.message, this.error_);
|
|
|
|
// fire an error event on the player
|
|
this.trigger('error');
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Returns whether or not the player is in the "ended" state.
|
|
*
|
|
* @return {Boolean} True if the player is in the ended state, false if not.
|
|
* @method ended
|
|
*/
|
|
|
|
Player.prototype.ended = function ended() {
|
|
return this.techGet_('ended');
|
|
};
|
|
|
|
/**
|
|
* Returns whether or not the player is in the "seeking" state.
|
|
*
|
|
* @return {Boolean} True if the player is in the seeking state, false if not.
|
|
* @method seeking
|
|
*/
|
|
|
|
Player.prototype.seeking = function seeking() {
|
|
return this.techGet_('seeking');
|
|
};
|
|
|
|
/**
|
|
* Returns the TimeRanges of the media that are currently available
|
|
* for seeking to.
|
|
*
|
|
* @return {TimeRanges} the seekable intervals of the media timeline
|
|
* @method seekable
|
|
*/
|
|
|
|
Player.prototype.seekable = function seekable() {
|
|
return this.techGet_('seekable');
|
|
};
|
|
|
|
/**
|
|
* Report user activity
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method reportUserActivity
|
|
*/
|
|
|
|
Player.prototype.reportUserActivity = function reportUserActivity(event) {
|
|
this.userActivity_ = true;
|
|
};
|
|
|
|
/**
|
|
* Get/set if user is active
|
|
*
|
|
* @param {Boolean} bool Value when setting
|
|
* @return {Boolean} Value if user is active user when getting
|
|
* @method userActive
|
|
*/
|
|
|
|
Player.prototype.userActive = function userActive(bool) {
|
|
if (bool !== undefined) {
|
|
bool = !!bool;
|
|
if (bool !== this.userActive_) {
|
|
this.userActive_ = bool;
|
|
if (bool) {
|
|
// If the user was inactive and is now active we want to reset the
|
|
// inactivity timer
|
|
this.userActivity_ = true;
|
|
this.removeClass('vjs-user-inactive');
|
|
this.addClass('vjs-user-active');
|
|
this.trigger('useractive');
|
|
} else {
|
|
// We're switching the state to inactive manually, so erase any other
|
|
// activity
|
|
this.userActivity_ = false;
|
|
|
|
// Chrome/Safari/IE have bugs where when you change the cursor it can
|
|
// trigger a mousemove event. This causes an issue when you're hiding
|
|
// the cursor when the user is inactive, and a mousemove signals user
|
|
// activity. Making it impossible to go into inactive mode. Specifically
|
|
// this happens in fullscreen when we really need to hide the cursor.
|
|
//
|
|
// When this gets resolved in ALL browsers it can be removed
|
|
// https://code.google.com/p/chromium/issues/detail?id=103041
|
|
if (this.tech_) {
|
|
this.tech_.one('mousemove', function (e) {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
});
|
|
}
|
|
|
|
this.removeClass('vjs-user-active');
|
|
this.addClass('vjs-user-inactive');
|
|
this.trigger('userinactive');
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
return this.userActive_;
|
|
};
|
|
|
|
/**
|
|
* Listen for user activity based on timeout value
|
|
*
|
|
* @private
|
|
* @method listenForUserActivity_
|
|
*/
|
|
|
|
Player.prototype.listenForUserActivity_ = function listenForUserActivity_() {
|
|
var mouseInProgress = undefined,
|
|
lastMoveX = undefined,
|
|
lastMoveY = undefined;
|
|
|
|
var handleActivity = Fn.bind(this, this.reportUserActivity);
|
|
|
|
var handleMouseMove = function handleMouseMove(e) {
|
|
// #1068 - Prevent mousemove spamming
|
|
// Chrome Bug: https://code.google.com/p/chromium/issues/detail?id=366970
|
|
if (e.screenX !== lastMoveX || e.screenY !== lastMoveY) {
|
|
lastMoveX = e.screenX;
|
|
lastMoveY = e.screenY;
|
|
handleActivity();
|
|
}
|
|
};
|
|
|
|
var handleMouseDown = function handleMouseDown() {
|
|
handleActivity();
|
|
// For as long as the they are touching the device or have their mouse down,
|
|
// we consider them active even if they're not moving their finger or mouse.
|
|
// So we want to continue to update that they are active
|
|
this.clearInterval(mouseInProgress);
|
|
// Setting userActivity=true now and setting the interval to the same time
|
|
// as the activityCheck interval (250) should ensure we never miss the
|
|
// next activityCheck
|
|
mouseInProgress = this.setInterval(handleActivity, 250);
|
|
};
|
|
|
|
var handleMouseUp = function handleMouseUp(event) {
|
|
handleActivity();
|
|
// Stop the interval that maintains activity if the mouse/touch is down
|
|
this.clearInterval(mouseInProgress);
|
|
};
|
|
|
|
// Any mouse movement will be considered user activity
|
|
this.on('mousedown', handleMouseDown);
|
|
this.on('mousemove', handleMouseMove);
|
|
this.on('mouseup', handleMouseUp);
|
|
|
|
// Listen for keyboard navigation
|
|
// Shouldn't need to use inProgress interval because of key repeat
|
|
this.on('keydown', handleActivity);
|
|
this.on('keyup', handleActivity);
|
|
|
|
// Run an interval every 250 milliseconds instead of stuffing everything into
|
|
// the mousemove/touchmove function itself, to prevent performance degradation.
|
|
// `this.reportUserActivity` simply sets this.userActivity_ to true, which
|
|
// then gets picked up by this loop
|
|
// http://ejohn.org/blog/learning-from-twitter/
|
|
var inactivityTimeout = undefined;
|
|
var activityCheck = this.setInterval(function () {
|
|
// Check to see if mouse/touch activity has happened
|
|
if (this.userActivity_) {
|
|
// Reset the activity tracker
|
|
this.userActivity_ = false;
|
|
|
|
// If the user state was inactive, set the state to active
|
|
this.userActive(true);
|
|
|
|
// Clear any existing inactivity timeout to start the timer over
|
|
this.clearTimeout(inactivityTimeout);
|
|
|
|
var timeout = this.options_['inactivityTimeout'];
|
|
if (timeout > 0) {
|
|
// In <timeout> milliseconds, if no more activity has occurred the
|
|
// user will be considered inactive
|
|
inactivityTimeout = this.setTimeout(function () {
|
|
// Protect against the case where the inactivityTimeout can trigger just
|
|
// before the next user activity is picked up by the activityCheck loop
|
|
// causing a flicker
|
|
if (!this.userActivity_) {
|
|
this.userActive(false);
|
|
}
|
|
}, timeout);
|
|
}
|
|
}
|
|
}, 250);
|
|
};
|
|
|
|
/**
|
|
* Gets or sets the current playback rate. A playback rate of
|
|
* 1.0 represents normal speed and 0.5 would indicate half-speed
|
|
* playback, for instance.
|
|
* @see https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-playbackrate
|
|
*
|
|
* @param {Number} rate New playback rate to set.
|
|
* @return {Number} Returns the new playback rate when setting
|
|
* @return {Number} Returns the current playback rate when getting
|
|
* @method playbackRate
|
|
*/
|
|
|
|
Player.prototype.playbackRate = function playbackRate(rate) {
|
|
if (rate !== undefined) {
|
|
this.techCall_('setPlaybackRate', rate);
|
|
return this;
|
|
}
|
|
|
|
if (this.tech_ && this.tech_['featuresPlaybackRate']) {
|
|
return this.techGet_('playbackRate');
|
|
} else {
|
|
return 1.0;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Gets or sets the audio flag
|
|
*
|
|
* @param {Boolean} bool True signals that this is an audio player.
|
|
* @return {Boolean} Returns true if player is audio, false if not when getting
|
|
* @return {Player} Returns the player if setting
|
|
* @private
|
|
* @method isAudio
|
|
*/
|
|
|
|
Player.prototype.isAudio = function isAudio(bool) {
|
|
if (bool !== undefined) {
|
|
this.isAudio_ = !!bool;
|
|
return this;
|
|
}
|
|
|
|
return !!this.isAudio_;
|
|
};
|
|
|
|
/**
|
|
* Returns the current state of network activity for the element, from
|
|
* the codes in the list below.
|
|
* - NETWORK_EMPTY (numeric value 0)
|
|
* The element has not yet been initialised. All attributes are in
|
|
* their initial states.
|
|
* - NETWORK_IDLE (numeric value 1)
|
|
* The element's resource selection algorithm is active and has
|
|
* selected a resource, but it is not actually using the network at
|
|
* this time.
|
|
* - NETWORK_LOADING (numeric value 2)
|
|
* The user agent is actively trying to download data.
|
|
* - NETWORK_NO_SOURCE (numeric value 3)
|
|
* The element's resource selection algorithm is active, but it has
|
|
* not yet found a resource to use.
|
|
*
|
|
* @see https://html.spec.whatwg.org/multipage/embedded-content.html#network-states
|
|
* @return {Number} the current network activity state
|
|
* @method networkState
|
|
*/
|
|
|
|
Player.prototype.networkState = function networkState() {
|
|
return this.techGet_('networkState');
|
|
};
|
|
|
|
/**
|
|
* Returns a value that expresses the current state of the element
|
|
* with respect to rendering the current playback position, from the
|
|
* codes in the list below.
|
|
* - HAVE_NOTHING (numeric value 0)
|
|
* No information regarding the media resource is available.
|
|
* - HAVE_METADATA (numeric value 1)
|
|
* Enough of the resource has been obtained that the duration of the
|
|
* resource is available.
|
|
* - HAVE_CURRENT_DATA (numeric value 2)
|
|
* Data for the immediate current playback position is available.
|
|
* - HAVE_FUTURE_DATA (numeric value 3)
|
|
* Data for the immediate current playback position is available, as
|
|
* well as enough data for the user agent to advance the current
|
|
* playback position in the direction of playback.
|
|
* - HAVE_ENOUGH_DATA (numeric value 4)
|
|
* The user agent estimates that enough data is available for
|
|
* playback to proceed uninterrupted.
|
|
*
|
|
* @see https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-readystate
|
|
* @return {Number} the current playback rendering state
|
|
* @method readyState
|
|
*/
|
|
|
|
Player.prototype.readyState = function readyState() {
|
|
return this.techGet_('readyState');
|
|
};
|
|
|
|
/**
|
|
* Get a video track list
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#videotracklist
|
|
*
|
|
* @return {VideoTrackList} thes current video track list
|
|
* @method videoTracks
|
|
*/
|
|
|
|
Player.prototype.videoTracks = function videoTracks() {
|
|
// if we have not yet loadTech_, we create videoTracks_
|
|
// these will be passed to the tech during loading
|
|
if (!this.tech_) {
|
|
this.videoTracks_ = this.videoTracks_ || new _tracksVideoTrackListJs2['default']();
|
|
return this.videoTracks_;
|
|
}
|
|
|
|
return this.tech_.videoTracks();
|
|
};
|
|
|
|
/**
|
|
* Get an audio track list
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#audiotracklist
|
|
*
|
|
* @return {AudioTrackList} thes current audio track list
|
|
* @method audioTracks
|
|
*/
|
|
|
|
Player.prototype.audioTracks = function audioTracks() {
|
|
// if we have not yet loadTech_, we create videoTracks_
|
|
// these will be passed to the tech during loading
|
|
if (!this.tech_) {
|
|
this.audioTracks_ = this.audioTracks_ || new _tracksAudioTrackListJs2['default']();
|
|
return this.audioTracks_;
|
|
}
|
|
|
|
return this.tech_.audioTracks();
|
|
};
|
|
|
|
/*
|
|
* Text tracks are tracks of timed text events.
|
|
* Captions - text displayed over the video for the hearing impaired
|
|
* Subtitles - text displayed over the video for those who don't understand language in the video
|
|
* Chapters - text displayed in a menu allowing the user to jump to particular points (chapters) in the video
|
|
* Descriptions (not supported yet) - audio descriptions that are read back to the user by a screen reading device
|
|
*/
|
|
|
|
/**
|
|
* Get an array of associated text tracks. captions, subtitles, chapters, descriptions
|
|
* http://www.w3.org/html/wg/drafts/html/master/embedded-content-0.html#dom-media-texttracks
|
|
*
|
|
* @return {Array} Array of track objects
|
|
* @method textTracks
|
|
*/
|
|
|
|
Player.prototype.textTracks = function textTracks() {
|
|
// cannot use techGet_ directly because it checks to see whether the tech is ready.
|
|
// Flash is unlikely to be ready in time but textTracks should still work.
|
|
return this.tech_ && this.tech_['textTracks']();
|
|
};
|
|
|
|
/**
|
|
* Get an array of remote text tracks
|
|
*
|
|
* @return {Array}
|
|
* @method remoteTextTracks
|
|
*/
|
|
|
|
Player.prototype.remoteTextTracks = function remoteTextTracks() {
|
|
return this.tech_ && this.tech_['remoteTextTracks']();
|
|
};
|
|
|
|
/**
|
|
* Get an array of remote html track elements
|
|
*
|
|
* @return {HTMLTrackElement[]}
|
|
* @method remoteTextTrackEls
|
|
*/
|
|
|
|
Player.prototype.remoteTextTrackEls = function remoteTextTrackEls() {
|
|
return this.tech_ && this.tech_['remoteTextTrackEls']();
|
|
};
|
|
|
|
/**
|
|
* Add a text track
|
|
* In addition to the W3C settings we allow adding additional info through options.
|
|
* http://www.w3.org/html/wg/drafts/html/master/embedded-content-0.html#dom-media-addtexttrack
|
|
*
|
|
* @param {String} kind Captions, subtitles, chapters, descriptions, or metadata
|
|
* @param {String=} label Optional label
|
|
* @param {String=} language Optional language
|
|
* @method addTextTrack
|
|
*/
|
|
|
|
Player.prototype.addTextTrack = function addTextTrack(kind, label, language) {
|
|
return this.tech_ && this.tech_['addTextTrack'](kind, label, language);
|
|
};
|
|
|
|
/**
|
|
* Add a remote text track
|
|
*
|
|
* @param {Object} options Options for remote text track
|
|
* @method addRemoteTextTrack
|
|
*/
|
|
|
|
Player.prototype.addRemoteTextTrack = function addRemoteTextTrack(options) {
|
|
return this.tech_ && this.tech_['addRemoteTextTrack'](options);
|
|
};
|
|
|
|
/**
|
|
* Remove a remote text track
|
|
*
|
|
* @param {Object} track Remote text track to remove
|
|
* @method removeRemoteTextTrack
|
|
*/
|
|
// destructure the input into an object with a track argument, defaulting to arguments[0]
|
|
// default the whole argument to an empty object if nothing was passed in
|
|
|
|
Player.prototype.removeRemoteTextTrack = function removeRemoteTextTrack() {
|
|
var _ref3 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
var _ref3$track = _ref3.track;
|
|
var track = _ref3$track === undefined ? arguments[0] : _ref3$track;
|
|
// jshint ignore:line
|
|
this.tech_ && this.tech_['removeRemoteTextTrack'](track);
|
|
};
|
|
|
|
/**
|
|
* Get video width
|
|
*
|
|
* @return {Number} Video width
|
|
* @method videoWidth
|
|
*/
|
|
|
|
Player.prototype.videoWidth = function videoWidth() {
|
|
return this.tech_ && this.tech_.videoWidth && this.tech_.videoWidth() || 0;
|
|
};
|
|
|
|
/**
|
|
* Get video height
|
|
*
|
|
* @return {Number} Video height
|
|
* @method videoHeight
|
|
*/
|
|
|
|
Player.prototype.videoHeight = function videoHeight() {
|
|
return this.tech_ && this.tech_.videoHeight && this.tech_.videoHeight() || 0;
|
|
};
|
|
|
|
// Methods to add support for
|
|
// initialTime: function(){ return this.techCall_('initialTime'); },
|
|
// startOffsetTime: function(){ return this.techCall_('startOffsetTime'); },
|
|
// played: function(){ return this.techCall_('played'); },
|
|
// defaultPlaybackRate: function(){ return this.techCall_('defaultPlaybackRate'); },
|
|
// defaultMuted: function(){ return this.techCall_('defaultMuted'); }
|
|
|
|
/**
|
|
* The player's language code
|
|
* NOTE: The language should be set in the player options if you want the
|
|
* the controls to be built with a specific language. Changing the lanugage
|
|
* later will not update controls text.
|
|
*
|
|
* @param {String} code The locale string
|
|
* @return {String} The locale string when getting
|
|
* @return {Player} self when setting
|
|
* @method language
|
|
*/
|
|
|
|
Player.prototype.language = function language(code) {
|
|
if (code === undefined) {
|
|
return this.language_;
|
|
}
|
|
|
|
this.language_ = ('' + code).toLowerCase();
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Get the player's language dictionary
|
|
* Merge every time, because a newly added plugin might call videojs.addLanguage() at any time
|
|
* Languages specified directly in the player options have precedence
|
|
*
|
|
* @return {Array} Array of languages
|
|
* @method languages
|
|
*/
|
|
|
|
Player.prototype.languages = function languages() {
|
|
return _utilsMergeOptionsJs2['default'](Player.prototype.options_.languages, this.languages_);
|
|
};
|
|
|
|
/**
|
|
* Converts track info to JSON
|
|
*
|
|
* @return {Object} JSON object of options
|
|
* @method toJSON
|
|
*/
|
|
|
|
Player.prototype.toJSON = function toJSON() {
|
|
var options = _utilsMergeOptionsJs2['default'](this.options_);
|
|
var tracks = options.tracks;
|
|
|
|
options.tracks = [];
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
|
|
// deep merge tracks and null out player so no circular references
|
|
track = _utilsMergeOptionsJs2['default'](track);
|
|
track.player = undefined;
|
|
options.tracks[i] = track;
|
|
}
|
|
|
|
return options;
|
|
};
|
|
|
|
/**
|
|
* Creates a simple modal dialog (an instance of the `ModalDialog`
|
|
* component) that immediately overlays the player with arbitrary
|
|
* content and removes itself when closed.
|
|
*
|
|
* @param {String|Function|Element|Array|Null} content
|
|
* Same as `ModalDialog#content`'s param of the same name.
|
|
*
|
|
* The most straight-forward usage is to provide a string or DOM
|
|
* element.
|
|
*
|
|
* @param {Object} [options]
|
|
* Extra options which will be passed on to the `ModalDialog`.
|
|
*
|
|
* @return {ModalDialog}
|
|
*/
|
|
|
|
Player.prototype.createModal = function createModal(content, options) {
|
|
var player = this;
|
|
|
|
options = options || {};
|
|
options.content = content || '';
|
|
|
|
var modal = new _modalDialog2['default'](player, options);
|
|
|
|
player.addChild(modal);
|
|
modal.on('dispose', function () {
|
|
player.removeChild(modal);
|
|
});
|
|
|
|
return modal.open();
|
|
};
|
|
|
|
/**
|
|
* Gets tag settings
|
|
*
|
|
* @param {Element} tag The player tag
|
|
* @return {Array} An array of sources and track objects
|
|
* @static
|
|
* @method getTagSettings
|
|
*/
|
|
|
|
Player.getTagSettings = function getTagSettings(tag) {
|
|
var baseOptions = {
|
|
'sources': [],
|
|
'tracks': []
|
|
};
|
|
|
|
var tagOptions = Dom.getElAttributes(tag);
|
|
var dataSetup = tagOptions['data-setup'];
|
|
|
|
// Check if data-setup attr exists.
|
|
if (dataSetup !== null) {
|
|
// Parse options JSON
|
|
|
|
var _safeParseTuple = _safeJsonParseTuple2['default'](dataSetup || '{}');
|
|
|
|
var err = _safeParseTuple[0];
|
|
var data = _safeParseTuple[1];
|
|
|
|
if (err) {
|
|
_utilsLogJs2['default'].error(err);
|
|
}
|
|
_objectAssign2['default'](tagOptions, data);
|
|
}
|
|
|
|
_objectAssign2['default'](baseOptions, tagOptions);
|
|
|
|
// Get tag children settings
|
|
if (tag.hasChildNodes()) {
|
|
var children = tag.childNodes;
|
|
|
|
for (var i = 0, j = children.length; i < j; i++) {
|
|
var child = children[i];
|
|
// Change case needed: http://ejohn.org/blog/nodename-case-sensitivity/
|
|
var childName = child.nodeName.toLowerCase();
|
|
if (childName === 'source') {
|
|
baseOptions.sources.push(Dom.getElAttributes(child));
|
|
} else if (childName === 'track') {
|
|
baseOptions.tracks.push(Dom.getElAttributes(child));
|
|
}
|
|
}
|
|
}
|
|
|
|
return baseOptions;
|
|
};
|
|
|
|
return Player;
|
|
})(_componentJs2['default']);
|
|
|
|
Player.players = {};
|
|
|
|
var navigator = _globalWindow2['default'].navigator;
|
|
/*
|
|
* Player instance options, surfaced using options
|
|
* options = Player.prototype.options_
|
|
* Make changes in options, not here.
|
|
*
|
|
* @type {Object}
|
|
* @private
|
|
*/
|
|
Player.prototype.options_ = {
|
|
// Default order of fallback technology
|
|
techOrder: ['html5', 'flash'],
|
|
// techOrder: ['flash','html5'],
|
|
|
|
html5: {},
|
|
flash: {},
|
|
|
|
// defaultVolume: 0.85,
|
|
defaultVolume: 0.00, // The freakin seaguls are driving me crazy!
|
|
|
|
// default inactivity timeout
|
|
inactivityTimeout: 2000,
|
|
|
|
// default playback rates
|
|
playbackRates: [],
|
|
// Add playback rate selection by adding rates
|
|
// 'playbackRates': [0.5, 1, 1.5, 2],
|
|
|
|
// Included control sets
|
|
children: ['mediaLoader', 'posterImage', 'textTrackDisplay', 'loadingSpinner', 'bigPlayButton', 'controlBar', 'errorDisplay', 'textTrackSettings'],
|
|
|
|
language: _globalDocument2['default'].getElementsByTagName('html')[0].getAttribute('lang') || navigator.languages && navigator.languages[0] || navigator.userLanguage || navigator.language || 'en',
|
|
|
|
// locales and their language translations
|
|
languages: {},
|
|
|
|
// Default message to show when a video cannot be played.
|
|
notSupportedMessage: 'No compatible source was found for this media.'
|
|
};
|
|
|
|
/**
|
|
* Fired when the player has initial duration and dimension information
|
|
*
|
|
* @event loadedmetadata
|
|
*/
|
|
Player.prototype.handleLoadedMetaData_;
|
|
|
|
/**
|
|
* Fired when the player has downloaded data at the current playback position
|
|
*
|
|
* @event loadeddata
|
|
*/
|
|
Player.prototype.handleLoadedData_;
|
|
|
|
/**
|
|
* Fired when the user is active, e.g. moves the mouse over the player
|
|
*
|
|
* @event useractive
|
|
*/
|
|
Player.prototype.handleUserActive_;
|
|
|
|
/**
|
|
* Fired when the user is inactive, e.g. a short delay after the last mouse move or control interaction
|
|
*
|
|
* @event userinactive
|
|
*/
|
|
Player.prototype.handleUserInactive_;
|
|
|
|
/**
|
|
* Fired when the current playback position has changed *
|
|
* During playback this is fired every 15-250 milliseconds, depending on the
|
|
* playback technology in use.
|
|
*
|
|
* @event timeupdate
|
|
*/
|
|
Player.prototype.handleTimeUpdate_;
|
|
|
|
/**
|
|
* Fired when video playback ends
|
|
*
|
|
* @event ended
|
|
*/
|
|
Player.prototype.handleTechEnded_;
|
|
|
|
/**
|
|
* Fired when the volume changes
|
|
*
|
|
* @event volumechange
|
|
*/
|
|
Player.prototype.handleVolumeChange_;
|
|
|
|
/**
|
|
* Fired when an error occurs
|
|
*
|
|
* @event error
|
|
*/
|
|
Player.prototype.handleError_;
|
|
|
|
Player.prototype.flexNotSupported_ = function () {
|
|
var elem = _globalDocument2['default'].createElement('i');
|
|
|
|
// Note: We don't actually use flexBasis (or flexOrder), but it's one of the more
|
|
// common flex features that we can rely on when checking for flex support.
|
|
return !('flexBasis' in elem.style || 'webkitFlexBasis' in elem.style || 'mozFlexBasis' in elem.style || 'msFlexBasis' in elem.style || 'msFlexOrder' in elem.style) /* IE10-specific (2012 flex spec) */;
|
|
};
|
|
|
|
_componentJs2['default'].registerComponent('Player', Player);
|
|
exports['default'] = Player;
|
|
module.exports = exports['default'];
|
|
// If empty string, make it a parsable json object.
|
|
|
|
},{"./big-play-button.js":63,"./component.js":67,"./control-bar/control-bar.js":70,"./error-display.js":103,"./fullscreen-api.js":106,"./loading-spinner.js":107,"./media-error.js":108,"./modal-dialog":112,"./poster-image.js":117,"./tech/html5.js":122,"./tech/loader.js":123,"./tech/tech.js":124,"./tracks/audio-track-list.js":125,"./tracks/text-track-display.js":130,"./tracks/text-track-list-converter.js":131,"./tracks/text-track-settings.js":133,"./tracks/video-track-list.js":138,"./utils/browser.js":140,"./utils/buffer.js":141,"./utils/dom.js":143,"./utils/events.js":144,"./utils/fn.js":145,"./utils/guid.js":147,"./utils/log.js":148,"./utils/merge-options.js":149,"./utils/stylesheet.js":150,"./utils/time-ranges.js":151,"./utils/to-title-case.js":152,"global/document":1,"global/window":2,"object.assign":45,"safe-json-parse/tuple":54}],114:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file plugins.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _playerJs = _dereq_('./player.js');
|
|
|
|
var _playerJs2 = _interopRequireDefault(_playerJs);
|
|
|
|
/**
|
|
* The method for registering a video.js plugin
|
|
*
|
|
* @param {String} name The name of the plugin
|
|
* @param {Function} init The function that is run when the player inits
|
|
* @method plugin
|
|
*/
|
|
var plugin = function plugin(name, init) {
|
|
_playerJs2['default'].prototype[name] = init;
|
|
};
|
|
|
|
exports['default'] = plugin;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./player.js":113}],115:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file popup-button.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _clickableComponentJs = _dereq_('../clickable-component.js');
|
|
|
|
var _clickableComponentJs2 = _interopRequireDefault(_clickableComponentJs);
|
|
|
|
var _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _popupJs = _dereq_('./popup.js');
|
|
|
|
var _popupJs2 = _interopRequireDefault(_popupJs);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('../utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
/**
|
|
* A button class with a popup control
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends ClickableComponent
|
|
* @class PopupButton
|
|
*/
|
|
|
|
var PopupButton = (function (_ClickableComponent) {
|
|
_inherits(PopupButton, _ClickableComponent);
|
|
|
|
function PopupButton(player) {
|
|
var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
_classCallCheck(this, PopupButton);
|
|
|
|
_ClickableComponent.call(this, player, options);
|
|
|
|
this.update();
|
|
}
|
|
|
|
/**
|
|
* Update popup
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
PopupButton.prototype.update = function update() {
|
|
var popup = this.createPopup();
|
|
|
|
if (this.popup) {
|
|
this.removeChild(this.popup);
|
|
}
|
|
|
|
this.popup = popup;
|
|
this.addChild(popup);
|
|
|
|
if (this.items && this.items.length === 0) {
|
|
this.hide();
|
|
} else if (this.items && this.items.length > 1) {
|
|
this.show();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create popup - Override with specific functionality for component
|
|
*
|
|
* @return {Popup} The constructed popup
|
|
* @method createPopup
|
|
*/
|
|
|
|
PopupButton.prototype.createPopup = function createPopup() {};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
PopupButton.prototype.createEl = function createEl() {
|
|
return _ClickableComponent.prototype.createEl.call(this, 'div', {
|
|
className: this.buildCSSClass()
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Allow sub components to stack CSS class names
|
|
*
|
|
* @return {String} The constructed class name
|
|
* @method buildCSSClass
|
|
*/
|
|
|
|
PopupButton.prototype.buildCSSClass = function buildCSSClass() {
|
|
var menuButtonClass = 'vjs-menu-button';
|
|
|
|
// If the inline option is passed, we want to use different styles altogether.
|
|
if (this.options_.inline === true) {
|
|
menuButtonClass += '-inline';
|
|
} else {
|
|
menuButtonClass += '-popup';
|
|
}
|
|
|
|
return 'vjs-menu-button ' + menuButtonClass + ' ' + _ClickableComponent.prototype.buildCSSClass.call(this);
|
|
};
|
|
|
|
return PopupButton;
|
|
})(_clickableComponentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('PopupButton', PopupButton);
|
|
exports['default'] = PopupButton;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../clickable-component.js":65,"../component.js":67,"../utils/dom.js":143,"../utils/fn.js":145,"../utils/to-title-case.js":152,"./popup.js":116}],116:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file popup.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsEventsJs = _dereq_('../utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
/**
|
|
* The Popup component is used to build pop up controls.
|
|
*
|
|
* @extends Component
|
|
* @class Popup
|
|
*/
|
|
|
|
var Popup = (function (_Component) {
|
|
_inherits(Popup, _Component);
|
|
|
|
function Popup() {
|
|
_classCallCheck(this, Popup);
|
|
|
|
_Component.apply(this, arguments);
|
|
}
|
|
|
|
/**
|
|
* Add a popup item to the popup
|
|
*
|
|
* @param {Object|String} component Component or component type to add
|
|
* @method addItem
|
|
*/
|
|
|
|
Popup.prototype.addItem = function addItem(component) {
|
|
this.addChild(component);
|
|
component.on('click', Fn.bind(this, function () {
|
|
this.unlockShowing();
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Popup.prototype.createEl = function createEl() {
|
|
var contentElType = this.options_.contentElType || 'ul';
|
|
this.contentEl_ = Dom.createEl(contentElType, {
|
|
className: 'vjs-menu-content'
|
|
});
|
|
var el = _Component.prototype.createEl.call(this, 'div', {
|
|
append: this.contentEl_,
|
|
className: 'vjs-menu'
|
|
});
|
|
el.appendChild(this.contentEl_);
|
|
|
|
// Prevent clicks from bubbling up. Needed for Popup Buttons,
|
|
// where a click on the parent is significant
|
|
Events.on(el, 'click', function (event) {
|
|
event.preventDefault();
|
|
event.stopImmediatePropagation();
|
|
});
|
|
|
|
return el;
|
|
};
|
|
|
|
return Popup;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('Popup', Popup);
|
|
exports['default'] = Popup;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../utils/dom.js":143,"../utils/events.js":144,"../utils/fn.js":145}],117:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file poster-image.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _clickableComponentJs = _dereq_('./clickable-component.js');
|
|
|
|
var _clickableComponentJs2 = _interopRequireDefault(_clickableComponentJs);
|
|
|
|
var _componentJs = _dereq_('./component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsDomJs = _dereq_('./utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('./utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
/**
|
|
* The component that handles showing the poster image.
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Button
|
|
* @class PosterImage
|
|
*/
|
|
|
|
var PosterImage = (function (_ClickableComponent) {
|
|
_inherits(PosterImage, _ClickableComponent);
|
|
|
|
function PosterImage(player, options) {
|
|
_classCallCheck(this, PosterImage);
|
|
|
|
_ClickableComponent.call(this, player, options);
|
|
|
|
this.update();
|
|
player.on('posterchange', Fn.bind(this, this.update));
|
|
}
|
|
|
|
/**
|
|
* Clean up the poster image
|
|
*
|
|
* @method dispose
|
|
*/
|
|
|
|
PosterImage.prototype.dispose = function dispose() {
|
|
this.player().off('posterchange', this.update);
|
|
_ClickableComponent.prototype.dispose.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the poster's image element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
PosterImage.prototype.createEl = function createEl() {
|
|
var el = Dom.createEl('div', {
|
|
className: 'vjs-poster',
|
|
|
|
// Don't want poster to be tabbable.
|
|
tabIndex: -1
|
|
});
|
|
|
|
// To ensure the poster image resizes while maintaining its original aspect
|
|
// ratio, use a div with `background-size` when available. For browsers that
|
|
// do not support `background-size` (e.g. IE8), fall back on using a regular
|
|
// img element.
|
|
if (!browser.BACKGROUND_SIZE_SUPPORTED) {
|
|
this.fallbackImg_ = Dom.createEl('img');
|
|
el.appendChild(this.fallbackImg_);
|
|
}
|
|
|
|
return el;
|
|
};
|
|
|
|
/**
|
|
* Event handler for updates to the player's poster source
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
PosterImage.prototype.update = function update() {
|
|
var url = this.player().poster();
|
|
|
|
this.setSrc(url);
|
|
|
|
// If there's no poster source we should display:none on this component
|
|
// so it's not still clickable or right-clickable
|
|
if (url) {
|
|
this.show();
|
|
} else {
|
|
this.hide();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Set the poster source depending on the display method
|
|
*
|
|
* @param {String} url The URL to the poster source
|
|
* @method setSrc
|
|
*/
|
|
|
|
PosterImage.prototype.setSrc = function setSrc(url) {
|
|
if (this.fallbackImg_) {
|
|
this.fallbackImg_.src = url;
|
|
} else {
|
|
var backgroundImage = '';
|
|
// Any falsey values should stay as an empty string, otherwise
|
|
// this will throw an extra error
|
|
if (url) {
|
|
backgroundImage = 'url("' + url + '")';
|
|
}
|
|
|
|
this.el_.style.backgroundImage = backgroundImage;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Event handler for clicks on the poster image
|
|
*
|
|
* @method handleClick
|
|
*/
|
|
|
|
PosterImage.prototype.handleClick = function handleClick() {
|
|
// We don't want a click to trigger playback when controls are disabled
|
|
// but CSS should be hiding the poster to prevent that from happening
|
|
if (this.player_.paused()) {
|
|
this.player_.play();
|
|
} else {
|
|
this.player_.pause();
|
|
}
|
|
};
|
|
|
|
return PosterImage;
|
|
})(_clickableComponentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('PosterImage', PosterImage);
|
|
exports['default'] = PosterImage;
|
|
module.exports = exports['default'];
|
|
|
|
},{"./clickable-component.js":65,"./component.js":67,"./utils/browser.js":140,"./utils/dom.js":143,"./utils/fn.js":145}],118:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file setup.js
|
|
*
|
|
* Functions for automatically setting up a player
|
|
* based on the data-setup attribute of the video tag
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _windowLoaded = false;
|
|
var videojs = undefined;
|
|
|
|
// Automatically set up any tags that have a data-setup attribute
|
|
var autoSetup = function autoSetup() {
|
|
// One day, when we stop supporting IE8, go back to this, but in the meantime...*hack hack hack*
|
|
// var vids = Array.prototype.slice.call(document.getElementsByTagName('video'));
|
|
// var audios = Array.prototype.slice.call(document.getElementsByTagName('audio'));
|
|
// var mediaEls = vids.concat(audios);
|
|
|
|
// Because IE8 doesn't support calling slice on a node list, we need to loop through each list of elements
|
|
// to build up a new, combined list of elements.
|
|
var vids = _globalDocument2['default'].getElementsByTagName('video');
|
|
var audios = _globalDocument2['default'].getElementsByTagName('audio');
|
|
var mediaEls = [];
|
|
if (vids && vids.length > 0) {
|
|
for (var i = 0, e = vids.length; i < e; i++) {
|
|
mediaEls.push(vids[i]);
|
|
}
|
|
}
|
|
if (audios && audios.length > 0) {
|
|
for (var i = 0, e = audios.length; i < e; i++) {
|
|
mediaEls.push(audios[i]);
|
|
}
|
|
}
|
|
|
|
// Check if any media elements exist
|
|
if (mediaEls && mediaEls.length > 0) {
|
|
|
|
for (var i = 0, e = mediaEls.length; i < e; i++) {
|
|
var mediaEl = mediaEls[i];
|
|
|
|
// Check if element exists, has getAttribute func.
|
|
// IE seems to consider typeof el.getAttribute == 'object' instead of 'function' like expected, at least when loading the player immediately.
|
|
if (mediaEl && mediaEl.getAttribute) {
|
|
|
|
// Make sure this player hasn't already been set up.
|
|
if (mediaEl['player'] === undefined) {
|
|
var options = mediaEl.getAttribute('data-setup');
|
|
|
|
// Check if data-setup attr exists.
|
|
// We only auto-setup if they've added the data-setup attr.
|
|
if (options !== null) {
|
|
// Create new video.js instance.
|
|
var player = videojs(mediaEl);
|
|
}
|
|
}
|
|
|
|
// If getAttribute isn't defined, we need to wait for the DOM.
|
|
} else {
|
|
autoSetupTimeout(1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// No videos were found, so keep looping unless page is finished loading.
|
|
} else if (!_windowLoaded) {
|
|
autoSetupTimeout(1);
|
|
}
|
|
};
|
|
|
|
// Pause to let the DOM keep processing
|
|
var autoSetupTimeout = function autoSetupTimeout(wait, vjs) {
|
|
if (vjs) {
|
|
videojs = vjs;
|
|
}
|
|
|
|
setTimeout(autoSetup, wait);
|
|
};
|
|
|
|
if (_globalDocument2['default'].readyState === 'complete') {
|
|
_windowLoaded = true;
|
|
} else {
|
|
Events.one(_globalWindow2['default'], 'load', function () {
|
|
_windowLoaded = true;
|
|
});
|
|
}
|
|
|
|
var hasLoaded = function hasLoaded() {
|
|
return _windowLoaded;
|
|
};
|
|
|
|
exports.autoSetup = autoSetup;
|
|
exports.autoSetupTimeout = autoSetupTimeout;
|
|
exports.hasLoaded = hasLoaded;
|
|
|
|
},{"./utils/events.js":144,"global/document":1,"global/window":2}],119:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file slider.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
/**
|
|
* The base functionality for sliders like the volume bar and seek bar
|
|
*
|
|
* @param {Player|Object} player
|
|
* @param {Object=} options
|
|
* @extends Component
|
|
* @class Slider
|
|
*/
|
|
|
|
var Slider = (function (_Component) {
|
|
_inherits(Slider, _Component);
|
|
|
|
function Slider(player, options) {
|
|
_classCallCheck(this, Slider);
|
|
|
|
_Component.call(this, player, options);
|
|
|
|
// Set property names to bar to match with the child Slider class is looking for
|
|
this.bar = this.getChild(this.options_.barName);
|
|
|
|
// Set a horizontal or vertical class on the slider depending on the slider type
|
|
this.vertical(!!this.options_.vertical);
|
|
|
|
this.on('mousedown', this.handleMouseDown);
|
|
this.on('touchstart', this.handleMouseDown);
|
|
this.on('focus', this.handleFocus);
|
|
this.on('blur', this.handleBlur);
|
|
this.on('click', this.handleClick);
|
|
|
|
this.on(player, 'controlsvisible', this.update);
|
|
this.on(player, this.playerEvent, this.update);
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @param {String} type Type of element to create
|
|
* @param {Object=} props List of properties in Object form
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Slider.prototype.createEl = function createEl(type) {
|
|
var props = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
var attributes = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
|
|
|
// Add the slider element class to all sub classes
|
|
props.className = props.className + ' vjs-slider';
|
|
props = _objectAssign2['default']({
|
|
tabIndex: 0
|
|
}, props);
|
|
|
|
attributes = _objectAssign2['default']({
|
|
'role': 'slider',
|
|
'aria-valuenow': 0,
|
|
'aria-valuemin': 0,
|
|
'aria-valuemax': 100,
|
|
tabIndex: 0
|
|
}, attributes);
|
|
|
|
return _Component.prototype.createEl.call(this, type, props, attributes);
|
|
};
|
|
|
|
/**
|
|
* Handle mouse down on slider
|
|
*
|
|
* @param {Object} event Mouse down event object
|
|
* @method handleMouseDown
|
|
*/
|
|
|
|
Slider.prototype.handleMouseDown = function handleMouseDown(event) {
|
|
var doc = this.bar.el_.ownerDocument;
|
|
|
|
event.preventDefault();
|
|
Dom.blockTextSelection();
|
|
|
|
this.addClass('vjs-sliding');
|
|
this.trigger('slideractive');
|
|
|
|
this.on(doc, 'mousemove', this.handleMouseMove);
|
|
this.on(doc, 'mouseup', this.handleMouseUp);
|
|
this.on(doc, 'touchmove', this.handleMouseMove);
|
|
this.on(doc, 'touchend', this.handleMouseUp);
|
|
|
|
this.handleMouseMove(event);
|
|
};
|
|
|
|
/**
|
|
* To be overridden by a subclass
|
|
*
|
|
* @method handleMouseMove
|
|
*/
|
|
|
|
Slider.prototype.handleMouseMove = function handleMouseMove() {};
|
|
|
|
/**
|
|
* Handle mouse up on Slider
|
|
*
|
|
* @method handleMouseUp
|
|
*/
|
|
|
|
Slider.prototype.handleMouseUp = function handleMouseUp() {
|
|
var doc = this.bar.el_.ownerDocument;
|
|
|
|
Dom.unblockTextSelection();
|
|
|
|
this.removeClass('vjs-sliding');
|
|
this.trigger('sliderinactive');
|
|
|
|
this.off(doc, 'mousemove', this.handleMouseMove);
|
|
this.off(doc, 'mouseup', this.handleMouseUp);
|
|
this.off(doc, 'touchmove', this.handleMouseMove);
|
|
this.off(doc, 'touchend', this.handleMouseUp);
|
|
|
|
this.update();
|
|
};
|
|
|
|
/**
|
|
* Update slider
|
|
*
|
|
* @method update
|
|
*/
|
|
|
|
Slider.prototype.update = function update() {
|
|
// In VolumeBar init we have a setTimeout for update that pops and update to the end of the
|
|
// execution stack. The player is destroyed before then update will cause an error
|
|
if (!this.el_) return;
|
|
|
|
// If scrubbing, we could use a cached value to make the handle keep up with the user's mouse.
|
|
// On HTML5 browsers scrubbing is really smooth, but some flash players are slow, so we might want to utilize this later.
|
|
// var progress = (this.player_.scrubbing()) ? this.player_.getCache().currentTime / this.player_.duration() : this.player_.currentTime() / this.player_.duration();
|
|
var progress = this.getPercent();
|
|
var bar = this.bar;
|
|
|
|
// If there's no bar...
|
|
if (!bar) return;
|
|
|
|
// Protect against no duration and other division issues
|
|
if (typeof progress !== 'number' || progress !== progress || progress < 0 || progress === Infinity) {
|
|
progress = 0;
|
|
}
|
|
|
|
// Convert to a percentage for setting
|
|
var percentage = (progress * 100).toFixed(2) + '%';
|
|
|
|
// Set the new bar width or height
|
|
if (this.vertical()) {
|
|
bar.el().style.height = percentage;
|
|
} else {
|
|
bar.el().style.width = percentage;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Calculate distance for slider
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method calculateDistance
|
|
*/
|
|
|
|
Slider.prototype.calculateDistance = function calculateDistance(event) {
|
|
var position = Dom.getPointerPosition(this.el_, event);
|
|
if (this.vertical()) {
|
|
return position.y;
|
|
}
|
|
return position.x;
|
|
};
|
|
|
|
/**
|
|
* Handle on focus for slider
|
|
*
|
|
* @method handleFocus
|
|
*/
|
|
|
|
Slider.prototype.handleFocus = function handleFocus() {
|
|
this.on(this.bar.el_.ownerDocument, 'keydown', this.handleKeyPress);
|
|
};
|
|
|
|
/**
|
|
* Handle key press for slider
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method handleKeyPress
|
|
*/
|
|
|
|
Slider.prototype.handleKeyPress = function handleKeyPress(event) {
|
|
if (event.which === 37 || event.which === 40) {
|
|
// Left and Down Arrows
|
|
event.preventDefault();
|
|
this.stepBack();
|
|
} else if (event.which === 38 || event.which === 39) {
|
|
// Up and Right Arrows
|
|
event.preventDefault();
|
|
this.stepForward();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Handle on blur for slider
|
|
*
|
|
* @method handleBlur
|
|
*/
|
|
|
|
Slider.prototype.handleBlur = function handleBlur() {
|
|
this.off(this.bar.el_.ownerDocument, 'keydown', this.handleKeyPress);
|
|
};
|
|
|
|
/**
|
|
* Listener for click events on slider, used to prevent clicks
|
|
* from bubbling up to parent elements like button menus.
|
|
*
|
|
* @param {Object} event Event object
|
|
* @method handleClick
|
|
*/
|
|
|
|
Slider.prototype.handleClick = function handleClick(event) {
|
|
event.stopImmediatePropagation();
|
|
event.preventDefault();
|
|
};
|
|
|
|
/**
|
|
* Get/set if slider is horizontal for vertical
|
|
*
|
|
* @param {Boolean} bool True if slider is vertical, false is horizontal
|
|
* @return {Boolean} True if slider is vertical, false is horizontal
|
|
* @method vertical
|
|
*/
|
|
|
|
Slider.prototype.vertical = function vertical(bool) {
|
|
if (bool === undefined) {
|
|
return this.vertical_ || false;
|
|
}
|
|
|
|
this.vertical_ = !!bool;
|
|
|
|
if (this.vertical_) {
|
|
this.addClass('vjs-slider-vertical');
|
|
} else {
|
|
this.addClass('vjs-slider-horizontal');
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
return Slider;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('Slider', Slider);
|
|
exports['default'] = Slider;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../utils/dom.js":143,"object.assign":45}],120:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file flash-rtmp.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
function FlashRtmpDecorator(Flash) {
|
|
Flash.streamingFormats = {
|
|
'rtmp/mp4': 'MP4',
|
|
'rtmp/flv': 'FLV'
|
|
};
|
|
|
|
Flash.streamFromParts = function (connection, stream) {
|
|
return connection + '&' + stream;
|
|
};
|
|
|
|
Flash.streamToParts = function (src) {
|
|
var parts = {
|
|
connection: '',
|
|
stream: ''
|
|
};
|
|
|
|
if (!src) return parts;
|
|
|
|
// Look for the normal URL separator we expect, '&'.
|
|
// If found, we split the URL into two pieces around the
|
|
// first '&'.
|
|
var connEnd = src.search(/&(?!\w+=)/);
|
|
var streamBegin = undefined;
|
|
if (connEnd !== -1) {
|
|
streamBegin = connEnd + 1;
|
|
} else {
|
|
// If there's not a '&', we use the last '/' as the delimiter.
|
|
connEnd = streamBegin = src.lastIndexOf('/') + 1;
|
|
if (connEnd === 0) {
|
|
// really, there's not a '/'?
|
|
connEnd = streamBegin = src.length;
|
|
}
|
|
}
|
|
parts.connection = src.substring(0, connEnd);
|
|
parts.stream = src.substring(streamBegin, src.length);
|
|
|
|
return parts;
|
|
};
|
|
|
|
Flash.isStreamingType = function (srcType) {
|
|
return srcType in Flash.streamingFormats;
|
|
};
|
|
|
|
// RTMP has four variations, any string starting
|
|
// with one of these protocols should be valid
|
|
Flash.RTMP_RE = /^rtmp[set]?:\/\//i;
|
|
|
|
Flash.isStreamingSrc = function (src) {
|
|
return Flash.RTMP_RE.test(src);
|
|
};
|
|
|
|
/**
|
|
* A source handler for RTMP urls
|
|
* @type {Object}
|
|
*/
|
|
Flash.rtmpSourceHandler = {};
|
|
|
|
/**
|
|
* Check if Flash can play the given videotype
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Flash.rtmpSourceHandler.canPlayType = function (type) {
|
|
if (Flash.isStreamingType(type)) {
|
|
return 'maybe';
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Check if Flash can handle the source natively
|
|
* @param {Object} source The source object
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Flash.rtmpSourceHandler.canHandleSource = function (source) {
|
|
var can = Flash.rtmpSourceHandler.canPlayType(source.type);
|
|
|
|
if (can) {
|
|
return can;
|
|
}
|
|
|
|
if (Flash.isStreamingSrc(source.src)) {
|
|
return 'maybe';
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* Pass the source to the flash object
|
|
* Adaptive source handlers will have more complicated workflows before passing
|
|
* video data to the video element
|
|
* @param {Object} source The source object
|
|
* @param {Flash} tech The instance of the Flash tech
|
|
* @param {Object} options The options to pass to the source
|
|
*/
|
|
Flash.rtmpSourceHandler.handleSource = function (source, tech, options) {
|
|
var srcParts = Flash.streamToParts(source.src);
|
|
|
|
tech['setRtmpConnection'](srcParts.connection);
|
|
tech['setRtmpStream'](srcParts.stream);
|
|
};
|
|
|
|
// Register the native source handler
|
|
Flash.registerSourceHandler(Flash.rtmpSourceHandler);
|
|
|
|
return Flash;
|
|
}
|
|
|
|
exports['default'] = FlashRtmpDecorator;
|
|
module.exports = exports['default'];
|
|
|
|
},{}],121:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file flash.js
|
|
* VideoJS-SWF - Custom Flash Player with HTML5-ish API
|
|
* https://github.com/zencoder/video-js-swf
|
|
* Not using setupTriggers. Using global onEvent func to distribute events
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _tech = _dereq_('./tech');
|
|
|
|
var _tech2 = _interopRequireDefault(_tech);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsUrlJs = _dereq_('../utils/url.js');
|
|
|
|
var Url = _interopRequireWildcard(_utilsUrlJs);
|
|
|
|
var _utilsTimeRangesJs = _dereq_('../utils/time-ranges.js');
|
|
|
|
var _flashRtmp = _dereq_('./flash-rtmp');
|
|
|
|
var _flashRtmp2 = _interopRequireDefault(_flashRtmp);
|
|
|
|
var _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var navigator = _globalWindow2['default'].navigator;
|
|
/**
|
|
* Flash Media Controller - Wrapper for fallback SWF API
|
|
*
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Tech
|
|
* @class Flash
|
|
*/
|
|
|
|
var Flash = (function (_Tech) {
|
|
_inherits(Flash, _Tech);
|
|
|
|
function Flash(options, ready) {
|
|
_classCallCheck(this, Flash);
|
|
|
|
_Tech.call(this, options, ready);
|
|
|
|
// Set the source when ready
|
|
if (options.source) {
|
|
this.ready(function () {
|
|
this.setSource(options.source);
|
|
}, true);
|
|
}
|
|
|
|
// Having issues with Flash reloading on certain page actions (hide/resize/fullscreen) in certain browsers
|
|
// This allows resetting the playhead when we catch the reload
|
|
if (options.startTime) {
|
|
this.ready(function () {
|
|
this.load();
|
|
this.play();
|
|
this.currentTime(options.startTime);
|
|
}, true);
|
|
}
|
|
|
|
// Add global window functions that the swf expects
|
|
// A 4.x workflow we weren't able to solve for in 5.0
|
|
// because of the need to hard code these functions
|
|
// into the swf for security reasons
|
|
_globalWindow2['default'].videojs = _globalWindow2['default'].videojs || {};
|
|
_globalWindow2['default'].videojs.Flash = _globalWindow2['default'].videojs.Flash || {};
|
|
_globalWindow2['default'].videojs.Flash.onReady = Flash.onReady;
|
|
_globalWindow2['default'].videojs.Flash.onEvent = Flash.onEvent;
|
|
_globalWindow2['default'].videojs.Flash.onError = Flash.onError;
|
|
|
|
this.on('seeked', function () {
|
|
this.lastSeekTarget_ = undefined;
|
|
});
|
|
}
|
|
|
|
// Create setters and getters for attributes
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Flash.prototype.createEl = function createEl() {
|
|
var options = this.options_;
|
|
|
|
// If video.js is hosted locally you should also set the location
|
|
// for the hosted swf, which should be relative to the page (not video.js)
|
|
// Otherwise this adds a CDN url.
|
|
// The CDN also auto-adds a swf URL for that specific version.
|
|
if (!options.swf) {
|
|
options.swf = '//vjs.zencdn.net/swf/5.0.1/video-js.swf';
|
|
}
|
|
|
|
// Generate ID for swf object
|
|
var objId = options.techId;
|
|
|
|
// Merge default flashvars with ones passed in to init
|
|
var flashVars = _objectAssign2['default']({
|
|
|
|
// SWF Callback Functions
|
|
'readyFunction': 'videojs.Flash.onReady',
|
|
'eventProxyFunction': 'videojs.Flash.onEvent',
|
|
'errorEventProxyFunction': 'videojs.Flash.onError',
|
|
|
|
// Player Settings
|
|
'autoplay': options.autoplay,
|
|
'preload': options.preload,
|
|
'loop': options.loop,
|
|
'muted': options.muted
|
|
|
|
}, options.flashVars);
|
|
|
|
// Merge default parames with ones passed in
|
|
var params = _objectAssign2['default']({
|
|
'wmode': 'opaque', // Opaque is needed to overlay controls, but can affect playback performance
|
|
'bgcolor': '#000000' // Using bgcolor prevents a white flash when the object is loading
|
|
}, options.params);
|
|
|
|
// Merge default attributes with ones passed in
|
|
var attributes = _objectAssign2['default']({
|
|
'id': objId,
|
|
'name': objId, // Both ID and Name needed or swf to identify itself
|
|
'class': 'vjs-tech'
|
|
}, options.attributes);
|
|
|
|
this.el_ = Flash.embed(options.swf, flashVars, params, attributes);
|
|
this.el_.tech = this;
|
|
|
|
return this.el_;
|
|
};
|
|
|
|
/**
|
|
* Play for flash tech
|
|
*
|
|
* @method play
|
|
*/
|
|
|
|
Flash.prototype.play = function play() {
|
|
if (this.ended()) {
|
|
this.setCurrentTime(0);
|
|
}
|
|
this.el_.vjs_play();
|
|
};
|
|
|
|
/**
|
|
* Pause for flash tech
|
|
*
|
|
* @method pause
|
|
*/
|
|
|
|
Flash.prototype.pause = function pause() {
|
|
this.el_.vjs_pause();
|
|
};
|
|
|
|
/**
|
|
* Get/set video
|
|
*
|
|
* @param {Object=} src Source object
|
|
* @return {Object}
|
|
* @method src
|
|
*/
|
|
|
|
Flash.prototype.src = function src(_src) {
|
|
if (_src === undefined) {
|
|
return this.currentSrc();
|
|
}
|
|
|
|
// Setting src through `src` not `setSrc` will be deprecated
|
|
return this.setSrc(_src);
|
|
};
|
|
|
|
/**
|
|
* Set video
|
|
*
|
|
* @param {Object=} src Source object
|
|
* @deprecated
|
|
* @method setSrc
|
|
*/
|
|
|
|
Flash.prototype.setSrc = function setSrc(src) {
|
|
// Make sure source URL is absolute.
|
|
src = Url.getAbsoluteURL(src);
|
|
this.el_.vjs_src(src);
|
|
|
|
// Currently the SWF doesn't autoplay if you load a source later.
|
|
// e.g. Load player w/ no source, wait 2s, set src.
|
|
if (this.autoplay()) {
|
|
var tech = this;
|
|
this.setTimeout(function () {
|
|
tech.play();
|
|
}, 0);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns true if the tech is currently seeking.
|
|
* @return {boolean} true if seeking
|
|
*/
|
|
|
|
Flash.prototype.seeking = function seeking() {
|
|
return this.lastSeekTarget_ !== undefined;
|
|
};
|
|
|
|
/**
|
|
* Set current time
|
|
*
|
|
* @param {Number} time Current time of video
|
|
* @method setCurrentTime
|
|
*/
|
|
|
|
Flash.prototype.setCurrentTime = function setCurrentTime(time) {
|
|
var seekable = this.seekable();
|
|
if (seekable.length) {
|
|
// clamp to the current seekable range
|
|
time = time > seekable.start(0) ? time : seekable.start(0);
|
|
time = time < seekable.end(seekable.length - 1) ? time : seekable.end(seekable.length - 1);
|
|
|
|
this.lastSeekTarget_ = time;
|
|
this.trigger('seeking');
|
|
this.el_.vjs_setProperty('currentTime', time);
|
|
_Tech.prototype.setCurrentTime.call(this);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get current time
|
|
*
|
|
* @param {Number=} time Current time of video
|
|
* @return {Number} Current time
|
|
* @method currentTime
|
|
*/
|
|
|
|
Flash.prototype.currentTime = function currentTime(time) {
|
|
// when seeking make the reported time keep up with the requested time
|
|
// by reading the time we're seeking to
|
|
if (this.seeking()) {
|
|
return this.lastSeekTarget_ || 0;
|
|
}
|
|
return this.el_.vjs_getProperty('currentTime');
|
|
};
|
|
|
|
/**
|
|
* Get current source
|
|
*
|
|
* @method currentSrc
|
|
*/
|
|
|
|
Flash.prototype.currentSrc = function currentSrc() {
|
|
if (this.currentSource_) {
|
|
return this.currentSource_.src;
|
|
} else {
|
|
return this.el_.vjs_getProperty('currentSrc');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Load media into player
|
|
*
|
|
* @method load
|
|
*/
|
|
|
|
Flash.prototype.load = function load() {
|
|
this.el_.vjs_load();
|
|
};
|
|
|
|
/**
|
|
* Get poster
|
|
*
|
|
* @method poster
|
|
*/
|
|
|
|
Flash.prototype.poster = function poster() {
|
|
this.el_.vjs_getProperty('poster');
|
|
};
|
|
|
|
/**
|
|
* Poster images are not handled by the Flash tech so make this a no-op
|
|
*
|
|
* @method setPoster
|
|
*/
|
|
|
|
Flash.prototype.setPoster = function setPoster() {};
|
|
|
|
/**
|
|
* Determine if can seek in media
|
|
*
|
|
* @return {TimeRangeObject}
|
|
* @method seekable
|
|
*/
|
|
|
|
Flash.prototype.seekable = function seekable() {
|
|
var duration = this.duration();
|
|
if (duration === 0) {
|
|
return _utilsTimeRangesJs.createTimeRange();
|
|
}
|
|
return _utilsTimeRangesJs.createTimeRange(0, duration);
|
|
};
|
|
|
|
/**
|
|
* Get buffered time range
|
|
*
|
|
* @return {TimeRangeObject}
|
|
* @method buffered
|
|
*/
|
|
|
|
Flash.prototype.buffered = function buffered() {
|
|
var ranges = this.el_.vjs_getProperty('buffered');
|
|
if (ranges.length === 0) {
|
|
return _utilsTimeRangesJs.createTimeRange();
|
|
}
|
|
return _utilsTimeRangesJs.createTimeRange(ranges[0][0], ranges[0][1]);
|
|
};
|
|
|
|
/**
|
|
* Get fullscreen support -
|
|
* Flash does not allow fullscreen through javascript
|
|
* so always returns false
|
|
*
|
|
* @return {Boolean} false
|
|
* @method supportsFullScreen
|
|
*/
|
|
|
|
Flash.prototype.supportsFullScreen = function supportsFullScreen() {
|
|
return false; // Flash does not allow fullscreen through javascript
|
|
};
|
|
|
|
/**
|
|
* Request to enter fullscreen
|
|
* Flash does not allow fullscreen through javascript
|
|
* so always returns false
|
|
*
|
|
* @return {Boolean} false
|
|
* @method enterFullScreen
|
|
*/
|
|
|
|
Flash.prototype.enterFullScreen = function enterFullScreen() {
|
|
return false;
|
|
};
|
|
|
|
return Flash;
|
|
})(_tech2['default']);
|
|
|
|
var _api = Flash.prototype;
|
|
var _readWrite = 'rtmpConnection,rtmpStream,preload,defaultPlaybackRate,playbackRate,autoplay,loop,mediaGroup,controller,controls,volume,muted,defaultMuted'.split(',');
|
|
var _readOnly = 'networkState,readyState,initialTime,duration,startOffsetTime,paused,ended,videoWidth,videoHeight'.split(',');
|
|
|
|
function _createSetter(attr) {
|
|
var attrUpper = attr.charAt(0).toUpperCase() + attr.slice(1);
|
|
_api['set' + attrUpper] = function (val) {
|
|
return this.el_.vjs_setProperty(attr, val);
|
|
};
|
|
}
|
|
function _createGetter(attr) {
|
|
_api[attr] = function () {
|
|
return this.el_.vjs_getProperty(attr);
|
|
};
|
|
}
|
|
|
|
// Create getter and setters for all read/write attributes
|
|
for (var i = 0; i < _readWrite.length; i++) {
|
|
_createGetter(_readWrite[i]);
|
|
_createSetter(_readWrite[i]);
|
|
}
|
|
|
|
// Create getters for read-only attributes
|
|
for (var i = 0; i < _readOnly.length; i++) {
|
|
_createGetter(_readOnly[i]);
|
|
}
|
|
|
|
/* Flash Support Testing -------------------------------------------------------- */
|
|
|
|
Flash.isSupported = function () {
|
|
return Flash.version()[0] >= 10;
|
|
// return swfobject.hasFlashPlayerVersion('10');
|
|
};
|
|
|
|
// Add Source Handler pattern functions to this tech
|
|
_tech2['default'].withSourceHandlers(Flash);
|
|
|
|
/*
|
|
* The default native source handler.
|
|
* This simply passes the source to the video element. Nothing fancy.
|
|
*
|
|
* @param {Object} source The source object
|
|
* @param {Flash} tech The instance of the Flash tech
|
|
*/
|
|
Flash.nativeSourceHandler = {};
|
|
|
|
/**
|
|
* Check if Flash can play the given videotype
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Flash.nativeSourceHandler.canPlayType = function (type) {
|
|
if (type in Flash.formats) {
|
|
return 'maybe';
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/*
|
|
* Check Flash can handle the source natively
|
|
*
|
|
* @param {Object} source The source object
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Flash.nativeSourceHandler.canHandleSource = function (source) {
|
|
var type;
|
|
|
|
function guessMimeType(src) {
|
|
var ext = Url.getFileExtension(src);
|
|
if (ext) {
|
|
return 'video/' + ext;
|
|
}
|
|
return '';
|
|
}
|
|
|
|
if (!source.type) {
|
|
type = guessMimeType(source.src);
|
|
} else {
|
|
// Strip code information from the type because we don't get that specific
|
|
type = source.type.replace(/;.*/, '').toLowerCase();
|
|
}
|
|
|
|
return Flash.nativeSourceHandler.canPlayType(type);
|
|
};
|
|
|
|
/*
|
|
* Pass the source to the flash object
|
|
* Adaptive source handlers will have more complicated workflows before passing
|
|
* video data to the video element
|
|
*
|
|
* @param {Object} source The source object
|
|
* @param {Flash} tech The instance of the Flash tech
|
|
* @param {Object} options The options to pass to the source
|
|
*/
|
|
Flash.nativeSourceHandler.handleSource = function (source, tech, options) {
|
|
tech.setSrc(source.src);
|
|
};
|
|
|
|
/*
|
|
* Clean up the source handler when disposing the player or switching sources..
|
|
* (no cleanup is needed when supporting the format natively)
|
|
*/
|
|
Flash.nativeSourceHandler.dispose = function () {};
|
|
|
|
// Register the native source handler
|
|
Flash.registerSourceHandler(Flash.nativeSourceHandler);
|
|
|
|
Flash.formats = {
|
|
'video/flv': 'FLV',
|
|
'video/x-flv': 'FLV',
|
|
'video/mp4': 'MP4',
|
|
'video/m4v': 'MP4'
|
|
};
|
|
|
|
Flash.onReady = function (currSwf) {
|
|
var el = Dom.getEl(currSwf);
|
|
var tech = el && el.tech;
|
|
|
|
// if there is no el then the tech has been disposed
|
|
// and the tech element was removed from the player div
|
|
if (tech && tech.el()) {
|
|
// check that the flash object is really ready
|
|
Flash.checkReady(tech);
|
|
}
|
|
};
|
|
|
|
// The SWF isn't always ready when it says it is. Sometimes the API functions still need to be added to the object.
|
|
// If it's not ready, we set a timeout to check again shortly.
|
|
Flash.checkReady = function (tech) {
|
|
// stop worrying if the tech has been disposed
|
|
if (!tech.el()) {
|
|
return;
|
|
}
|
|
|
|
// check if API property exists
|
|
if (tech.el().vjs_getProperty) {
|
|
// tell tech it's ready
|
|
tech.triggerReady();
|
|
} else {
|
|
// wait longer
|
|
this.setTimeout(function () {
|
|
Flash['checkReady'](tech);
|
|
}, 50);
|
|
}
|
|
};
|
|
|
|
// Trigger events from the swf on the player
|
|
Flash.onEvent = function (swfID, eventName) {
|
|
var tech = Dom.getEl(swfID).tech;
|
|
tech.trigger(eventName);
|
|
};
|
|
|
|
// Log errors from the swf
|
|
Flash.onError = function (swfID, err) {
|
|
var tech = Dom.getEl(swfID).tech;
|
|
|
|
// trigger MEDIA_ERR_SRC_NOT_SUPPORTED
|
|
if (err === 'srcnotfound') {
|
|
return tech.error(4);
|
|
}
|
|
|
|
// trigger a custom error
|
|
tech.error('FLASH: ' + err);
|
|
};
|
|
|
|
// Flash Version Check
|
|
Flash.version = function () {
|
|
var version = '0,0,0';
|
|
|
|
// IE
|
|
try {
|
|
version = new _globalWindow2['default'].ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version').replace(/\D+/g, ',').match(/^,?(.+),?$/)[1];
|
|
|
|
// other browsers
|
|
} catch (e) {
|
|
try {
|
|
if (navigator.mimeTypes['application/x-shockwave-flash'].enabledPlugin) {
|
|
version = (navigator.plugins['Shockwave Flash 2.0'] || navigator.plugins['Shockwave Flash']).description.replace(/\D+/g, ',').match(/^,?(.+),?$/)[1];
|
|
}
|
|
} catch (err) {}
|
|
}
|
|
return version.split(',');
|
|
};
|
|
|
|
// Flash embedding method. Only used in non-iframe mode
|
|
Flash.embed = function (swf, flashVars, params, attributes) {
|
|
var code = Flash.getEmbedCode(swf, flashVars, params, attributes);
|
|
|
|
// Get element by embedding code and retrieving created element
|
|
var obj = Dom.createEl('div', { innerHTML: code }).childNodes[0];
|
|
|
|
return obj;
|
|
};
|
|
|
|
Flash.getEmbedCode = function (swf, flashVars, params, attributes) {
|
|
var objTag = '<object type="application/x-shockwave-flash" ';
|
|
var flashVarsString = '';
|
|
var paramsString = '';
|
|
var attrsString = '';
|
|
|
|
// Convert flash vars to string
|
|
if (flashVars) {
|
|
Object.getOwnPropertyNames(flashVars).forEach(function (key) {
|
|
flashVarsString += key + '=' + flashVars[key] + '&';
|
|
});
|
|
}
|
|
|
|
// Add swf, flashVars, and other default params
|
|
params = _objectAssign2['default']({
|
|
'movie': swf,
|
|
'flashvars': flashVarsString,
|
|
'allowScriptAccess': 'always', // Required to talk to swf
|
|
'allowNetworking': 'all' // All should be default, but having security issues.
|
|
}, params);
|
|
|
|
// Create param tags string
|
|
Object.getOwnPropertyNames(params).forEach(function (key) {
|
|
paramsString += '<param name="' + key + '" value="' + params[key] + '" />';
|
|
});
|
|
|
|
attributes = _objectAssign2['default']({
|
|
// Add swf to attributes (need both for IE and Others to work)
|
|
'data': swf,
|
|
|
|
// Default to 100% width/height
|
|
'width': '100%',
|
|
'height': '100%'
|
|
|
|
}, attributes);
|
|
|
|
// Create Attributes string
|
|
Object.getOwnPropertyNames(attributes).forEach(function (key) {
|
|
attrsString += key + '="' + attributes[key] + '" ';
|
|
});
|
|
|
|
return '' + objTag + attrsString + '>' + paramsString + '</object>';
|
|
};
|
|
|
|
// Run Flash through the RTMP decorator
|
|
_flashRtmp2['default'](Flash);
|
|
|
|
_component2['default'].registerComponent('Flash', Flash);
|
|
_tech2['default'].registerTech('Flash', Flash);
|
|
exports['default'] = Flash;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component":67,"../utils/dom.js":143,"../utils/time-ranges.js":151,"../utils/url.js":153,"./flash-rtmp":120,"./tech":124,"global/window":2,"object.assign":45}],122:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file html5.js
|
|
* HTML5 Media Controller - Wrapper for HTML5 Media API
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _templateObject = _taggedTemplateLiteralLoose(['Text Tracks are being loaded from another origin but the crossorigin attribute isn\'t used. \n This may prevent text tracks from loading.'], ['Text Tracks are being loaded from another origin but the crossorigin attribute isn\'t used. \n This may prevent text tracks from loading.']);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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; }
|
|
|
|
function _taggedTemplateLiteralLoose(strings, raw) { strings.raw = raw; return strings; }
|
|
|
|
var _techJs = _dereq_('./tech.js');
|
|
|
|
var _techJs2 = _interopRequireDefault(_techJs);
|
|
|
|
var _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsDomJs = _dereq_('../utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsUrlJs = _dereq_('../utils/url.js');
|
|
|
|
var Url = _interopRequireWildcard(_utilsUrlJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsLogJs = _dereq_('../utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _tsml = _dereq_('tsml');
|
|
|
|
var _tsml2 = _interopRequireDefault(_tsml);
|
|
|
|
var _srcJsTracksTextTrackJs = _dereq_('../../../src/js/tracks/text-track.js');
|
|
|
|
var _srcJsTracksTextTrackJs2 = _interopRequireDefault(_srcJsTracksTextTrackJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var _utilsMergeOptionsJs = _dereq_('../utils/merge-options.js');
|
|
|
|
var _utilsMergeOptionsJs2 = _interopRequireDefault(_utilsMergeOptionsJs);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('../utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
/**
|
|
* HTML5 Media Controller - Wrapper for HTML5 Media API
|
|
*
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Tech
|
|
* @class Html5
|
|
*/
|
|
|
|
var Html5 = (function (_Tech) {
|
|
_inherits(Html5, _Tech);
|
|
|
|
function Html5(options, ready) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, Html5);
|
|
|
|
_Tech.call(this, options, ready);
|
|
|
|
var source = options.source;
|
|
var crossoriginTracks = false;
|
|
|
|
// Set the source if one is provided
|
|
// 1) Check if the source is new (if not, we want to keep the original so playback isn't interrupted)
|
|
// 2) Check to see if the network state of the tag was failed at init, and if so, reset the source
|
|
// anyway so the error gets fired.
|
|
if (source && (this.el_.currentSrc !== source.src || options.tag && options.tag.initNetworkState_ === 3)) {
|
|
this.setSource(source);
|
|
} else {
|
|
this.handleLateInit_(this.el_);
|
|
}
|
|
|
|
if (this.el_.hasChildNodes()) {
|
|
|
|
var nodes = this.el_.childNodes;
|
|
var nodesLength = nodes.length;
|
|
var removeNodes = [];
|
|
|
|
while (nodesLength--) {
|
|
var node = nodes[nodesLength];
|
|
var nodeName = node.nodeName.toLowerCase();
|
|
|
|
if (nodeName === 'track') {
|
|
if (!this.featuresNativeTextTracks) {
|
|
// Empty video tag tracks so the built-in player doesn't use them also.
|
|
// This may not be fast enough to stop HTML5 browsers from reading the tags
|
|
// so we'll need to turn off any default tracks if we're manually doing
|
|
// captions and subtitles. videoElement.textTracks
|
|
removeNodes.push(node);
|
|
} else {
|
|
// store HTMLTrackElement and TextTrack to remote list
|
|
this.remoteTextTrackEls().addTrackElement_(node);
|
|
this.remoteTextTracks().addTrack_(node.track);
|
|
if (!crossoriginTracks && !this.el_.hasAttribute('crossorigin') && Url.isCrossOrigin(node.src)) {
|
|
crossoriginTracks = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var i = 0; i < removeNodes.length; i++) {
|
|
this.el_.removeChild(removeNodes[i]);
|
|
}
|
|
}
|
|
|
|
var trackTypes = ['audio', 'video'];
|
|
|
|
// ProxyNativeTextTracks
|
|
trackTypes.forEach(function (type) {
|
|
var capitalType = _utilsToTitleCaseJs2['default'](type);
|
|
|
|
if (!_this['featuresNative' + capitalType + 'Tracks']) {
|
|
return;
|
|
}
|
|
var tl = _this.el()[type + 'Tracks'];
|
|
|
|
if (tl && tl.addEventListener) {
|
|
tl.addEventListener('change', Fn.bind(_this, _this['handle' + capitalType + 'TrackChange_']));
|
|
tl.addEventListener('addtrack', Fn.bind(_this, _this['handle' + capitalType + 'TrackAdd_']));
|
|
tl.addEventListener('removetrack', Fn.bind(_this, _this['handle' + capitalType + 'TrackRemove_']));
|
|
}
|
|
});
|
|
|
|
if (this.featuresNativeTextTracks) {
|
|
if (crossoriginTracks) {
|
|
_utilsLogJs2['default'].warn(_tsml2['default'](_templateObject));
|
|
}
|
|
|
|
this.handleTextTrackChange_ = Fn.bind(this, this.handleTextTrackChange);
|
|
this.handleTextTrackAdd_ = Fn.bind(this, this.handleTextTrackAdd);
|
|
this.handleTextTrackRemove_ = Fn.bind(this, this.handleTextTrackRemove);
|
|
this.proxyNativeTextTracks_();
|
|
}
|
|
|
|
// Determine if native controls should be used
|
|
// Our goal should be to get the custom controls on mobile solid everywhere
|
|
// so we can remove this all together. Right now this will block custom
|
|
// controls on touch enabled laptops like the Chrome Pixel
|
|
if (browser.TOUCH_ENABLED && options.nativeControlsForTouch === true || browser.IS_IPHONE || browser.IS_NATIVE_ANDROID) {
|
|
this.setControls(true);
|
|
}
|
|
|
|
this.triggerReady();
|
|
}
|
|
|
|
/* HTML5 Support Testing ---------------------------------------------------- */
|
|
|
|
/*
|
|
* Element for testing browser HTML5 video capabilities
|
|
*
|
|
* @type {Element}
|
|
* @constant
|
|
* @private
|
|
*/
|
|
|
|
/**
|
|
* Dispose of html5 media element
|
|
*
|
|
* @method dispose
|
|
*/
|
|
|
|
Html5.prototype.dispose = function dispose() {
|
|
var _this2 = this;
|
|
|
|
// Un-ProxyNativeTracks
|
|
['audio', 'video', 'text'].forEach(function (type) {
|
|
var capitalType = _utilsToTitleCaseJs2['default'](type);
|
|
var tl = _this2.el_[type + 'Tracks'];
|
|
|
|
if (tl && tl.removeEventListener) {
|
|
tl.removeEventListener('change', _this2['handle' + capitalType + 'TrackChange_']);
|
|
tl.removeEventListener('addtrack', _this2['handle' + capitalType + 'TrackAdd_']);
|
|
tl.removeEventListener('removetrack', _this2['handle' + capitalType + 'TrackRemove_']);
|
|
}
|
|
});
|
|
|
|
Html5.disposeMediaElement(this.el_);
|
|
// tech will handle clearing of the emulated track list
|
|
_Tech.prototype.dispose.call(this);
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
Html5.prototype.createEl = function createEl() {
|
|
var el = this.options_.tag;
|
|
|
|
// Check if this browser supports moving the element into the box.
|
|
// On the iPhone video will break if you move the element,
|
|
// So we have to create a brand new element.
|
|
if (!el || this['movingMediaElementInDOM'] === false) {
|
|
|
|
// If the original tag is still there, clone and remove it.
|
|
if (el) {
|
|
var clone = el.cloneNode(true);
|
|
el.parentNode.insertBefore(clone, el);
|
|
Html5.disposeMediaElement(el);
|
|
el = clone;
|
|
} else {
|
|
el = _globalDocument2['default'].createElement('video');
|
|
|
|
// determine if native controls should be used
|
|
var tagAttributes = this.options_.tag && Dom.getElAttributes(this.options_.tag);
|
|
var attributes = _utilsMergeOptionsJs2['default']({}, tagAttributes);
|
|
if (!browser.TOUCH_ENABLED || this.options_.nativeControlsForTouch !== true) {
|
|
delete attributes.controls;
|
|
}
|
|
|
|
Dom.setElAttributes(el, _objectAssign2['default'](attributes, {
|
|
id: this.options_.techId,
|
|
'class': 'vjs-tech'
|
|
}));
|
|
}
|
|
}
|
|
|
|
// Update specific tag settings, in case they were overridden
|
|
var settingsAttrs = ['autoplay', 'preload', 'loop', 'muted'];
|
|
for (var i = settingsAttrs.length - 1; i >= 0; i--) {
|
|
var attr = settingsAttrs[i];
|
|
var overwriteAttrs = {};
|
|
if (typeof this.options_[attr] !== 'undefined') {
|
|
overwriteAttrs[attr] = this.options_[attr];
|
|
}
|
|
Dom.setElAttributes(el, overwriteAttrs);
|
|
}
|
|
|
|
return el;
|
|
// jenniisawesome = true;
|
|
};
|
|
|
|
// If we're loading the playback object after it has started loading
|
|
// or playing the video (often with autoplay on) then the loadstart event
|
|
// has already fired and we need to fire it manually because many things
|
|
// rely on it.
|
|
|
|
Html5.prototype.handleLateInit_ = function handleLateInit_(el) {
|
|
var _this3 = this;
|
|
|
|
if (el.networkState === 0 || el.networkState === 3) {
|
|
// The video element hasn't started loading the source yet
|
|
// or didn't find a source
|
|
return;
|
|
}
|
|
|
|
if (el.readyState === 0) {
|
|
var _ret = (function () {
|
|
// NetworkState is set synchronously BUT loadstart is fired at the
|
|
// end of the current stack, usually before setInterval(fn, 0).
|
|
// So at this point we know loadstart may have already fired or is
|
|
// about to fire, and either way the player hasn't seen it yet.
|
|
// We don't want to fire loadstart prematurely here and cause a
|
|
// double loadstart so we'll wait and see if it happens between now
|
|
// and the next loop, and fire it if not.
|
|
// HOWEVER, we also want to make sure it fires before loadedmetadata
|
|
// which could also happen between now and the next loop, so we'll
|
|
// watch for that also.
|
|
var loadstartFired = false;
|
|
var setLoadstartFired = function setLoadstartFired() {
|
|
loadstartFired = true;
|
|
};
|
|
_this3.on('loadstart', setLoadstartFired);
|
|
|
|
var triggerLoadstart = function triggerLoadstart() {
|
|
// We did miss the original loadstart. Make sure the player
|
|
// sees loadstart before loadedmetadata
|
|
if (!loadstartFired) {
|
|
this.trigger('loadstart');
|
|
}
|
|
};
|
|
_this3.on('loadedmetadata', triggerLoadstart);
|
|
|
|
_this3.ready(function () {
|
|
this.off('loadstart', setLoadstartFired);
|
|
this.off('loadedmetadata', triggerLoadstart);
|
|
|
|
if (!loadstartFired) {
|
|
// We did miss the original native loadstart. Fire it now.
|
|
this.trigger('loadstart');
|
|
}
|
|
});
|
|
|
|
return {
|
|
v: undefined
|
|
};
|
|
})();
|
|
|
|
if (typeof _ret === 'object') return _ret.v;
|
|
}
|
|
|
|
// From here on we know that loadstart already fired and we missed it.
|
|
// The other readyState events aren't as much of a problem if we double
|
|
// them, so not going to go to as much trouble as loadstart to prevent
|
|
// that unless we find reason to.
|
|
var eventsToTrigger = ['loadstart'];
|
|
|
|
// loadedmetadata: newly equal to HAVE_METADATA (1) or greater
|
|
eventsToTrigger.push('loadedmetadata');
|
|
|
|
// loadeddata: newly increased to HAVE_CURRENT_DATA (2) or greater
|
|
if (el.readyState >= 2) {
|
|
eventsToTrigger.push('loadeddata');
|
|
}
|
|
|
|
// canplay: newly increased to HAVE_FUTURE_DATA (3) or greater
|
|
if (el.readyState >= 3) {
|
|
eventsToTrigger.push('canplay');
|
|
}
|
|
|
|
// canplaythrough: newly equal to HAVE_ENOUGH_DATA (4)
|
|
if (el.readyState >= 4) {
|
|
eventsToTrigger.push('canplaythrough');
|
|
}
|
|
|
|
// We still need to give the player time to add event listeners
|
|
this.ready(function () {
|
|
eventsToTrigger.forEach(function (type) {
|
|
this.trigger(type);
|
|
}, this);
|
|
});
|
|
};
|
|
|
|
Html5.prototype.proxyNativeTextTracks_ = function proxyNativeTextTracks_() {
|
|
var tt = this.el().textTracks;
|
|
|
|
if (tt) {
|
|
// Add tracks - if player is initialised after DOM loaded, textTracks
|
|
// will not trigger addtrack
|
|
for (var i = 0; i < tt.length; i++) {
|
|
this.textTracks().addTrack_(tt[i]);
|
|
}
|
|
|
|
if (tt.addEventListener) {
|
|
tt.addEventListener('change', this.handleTextTrackChange_);
|
|
tt.addEventListener('addtrack', this.handleTextTrackAdd_);
|
|
tt.addEventListener('removetrack', this.handleTextTrackRemove_);
|
|
}
|
|
}
|
|
};
|
|
|
|
Html5.prototype.handleTextTrackChange = function handleTextTrackChange(e) {
|
|
var tt = this.textTracks();
|
|
this.textTracks().trigger({
|
|
type: 'change',
|
|
target: tt,
|
|
currentTarget: tt,
|
|
srcElement: tt
|
|
});
|
|
};
|
|
|
|
Html5.prototype.handleTextTrackAdd = function handleTextTrackAdd(e) {
|
|
this.textTracks().addTrack_(e.track);
|
|
};
|
|
|
|
Html5.prototype.handleTextTrackRemove = function handleTextTrackRemove(e) {
|
|
this.textTracks().removeTrack_(e.track);
|
|
};
|
|
|
|
Html5.prototype.handleVideoTrackChange_ = function handleVideoTrackChange_(e) {
|
|
var vt = this.videoTracks();
|
|
this.videoTracks().trigger({
|
|
type: 'change',
|
|
target: vt,
|
|
currentTarget: vt,
|
|
srcElement: vt
|
|
});
|
|
};
|
|
|
|
Html5.prototype.handleVideoTrackAdd_ = function handleVideoTrackAdd_(e) {
|
|
this.videoTracks().addTrack_(e.track);
|
|
};
|
|
|
|
Html5.prototype.handleVideoTrackRemove_ = function handleVideoTrackRemove_(e) {
|
|
this.videoTracks().removeTrack_(e.track);
|
|
};
|
|
|
|
Html5.prototype.handleAudioTrackChange_ = function handleAudioTrackChange_(e) {
|
|
var audioTrackList = this.audioTracks();
|
|
this.audioTracks().trigger({
|
|
type: 'change',
|
|
target: audioTrackList,
|
|
currentTarget: audioTrackList,
|
|
srcElement: audioTrackList
|
|
});
|
|
};
|
|
|
|
Html5.prototype.handleAudioTrackAdd_ = function handleAudioTrackAdd_(e) {
|
|
this.audioTracks().addTrack_(e.track);
|
|
};
|
|
|
|
Html5.prototype.handleAudioTrackRemove_ = function handleAudioTrackRemove_(e) {
|
|
this.audioTracks().removeTrack_(e.track);
|
|
};
|
|
|
|
/**
|
|
* Play for html5 tech
|
|
*
|
|
* @method play
|
|
*/
|
|
|
|
Html5.prototype.play = function play() {
|
|
this.el_.play();
|
|
};
|
|
|
|
/**
|
|
* Pause for html5 tech
|
|
*
|
|
* @method pause
|
|
*/
|
|
|
|
Html5.prototype.pause = function pause() {
|
|
this.el_.pause();
|
|
};
|
|
|
|
/**
|
|
* Paused for html5 tech
|
|
*
|
|
* @return {Boolean}
|
|
* @method paused
|
|
*/
|
|
|
|
Html5.prototype.paused = function paused() {
|
|
return this.el_.paused;
|
|
};
|
|
|
|
/**
|
|
* Get current time
|
|
*
|
|
* @return {Number}
|
|
* @method currentTime
|
|
*/
|
|
|
|
Html5.prototype.currentTime = function currentTime() {
|
|
return this.el_.currentTime;
|
|
};
|
|
|
|
/**
|
|
* Set current time
|
|
*
|
|
* @param {Number} seconds Current time of video
|
|
* @method setCurrentTime
|
|
*/
|
|
|
|
Html5.prototype.setCurrentTime = function setCurrentTime(seconds) {
|
|
try {
|
|
this.el_.currentTime = seconds;
|
|
} catch (e) {
|
|
_utilsLogJs2['default'](e, 'Video is not ready. (Video.js)');
|
|
// this.warning(VideoJS.warnings.videoNotReady);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get duration
|
|
*
|
|
* @return {Number}
|
|
* @method duration
|
|
*/
|
|
|
|
Html5.prototype.duration = function duration() {
|
|
return this.el_.duration || 0;
|
|
};
|
|
|
|
/**
|
|
* Get a TimeRange object that represents the intersection
|
|
* of the time ranges for which the user agent has all
|
|
* relevant media
|
|
*
|
|
* @return {TimeRangeObject}
|
|
* @method buffered
|
|
*/
|
|
|
|
Html5.prototype.buffered = function buffered() {
|
|
return this.el_.buffered;
|
|
};
|
|
|
|
/**
|
|
* Get volume level
|
|
*
|
|
* @return {Number}
|
|
* @method volume
|
|
*/
|
|
|
|
Html5.prototype.volume = function volume() {
|
|
return this.el_.volume;
|
|
};
|
|
|
|
/**
|
|
* Set volume level
|
|
*
|
|
* @param {Number} percentAsDecimal Volume percent as a decimal
|
|
* @method setVolume
|
|
*/
|
|
|
|
Html5.prototype.setVolume = function setVolume(percentAsDecimal) {
|
|
this.el_.volume = percentAsDecimal;
|
|
};
|
|
|
|
/**
|
|
* Get if muted
|
|
*
|
|
* @return {Boolean}
|
|
* @method muted
|
|
*/
|
|
|
|
Html5.prototype.muted = function muted() {
|
|
return this.el_.muted;
|
|
};
|
|
|
|
/**
|
|
* Set muted
|
|
*
|
|
* @param {Boolean} If player is to be muted or note
|
|
* @method setMuted
|
|
*/
|
|
|
|
Html5.prototype.setMuted = function setMuted(muted) {
|
|
this.el_.muted = muted;
|
|
};
|
|
|
|
/**
|
|
* Get player width
|
|
*
|
|
* @return {Number}
|
|
* @method width
|
|
*/
|
|
|
|
Html5.prototype.width = function width() {
|
|
return this.el_.offsetWidth;
|
|
};
|
|
|
|
/**
|
|
* Get player height
|
|
*
|
|
* @return {Number}
|
|
* @method height
|
|
*/
|
|
|
|
Html5.prototype.height = function height() {
|
|
return this.el_.offsetHeight;
|
|
};
|
|
|
|
/**
|
|
* Get if there is fullscreen support
|
|
*
|
|
* @return {Boolean}
|
|
* @method supportsFullScreen
|
|
*/
|
|
|
|
Html5.prototype.supportsFullScreen = function supportsFullScreen() {
|
|
if (typeof this.el_.webkitEnterFullScreen === 'function') {
|
|
var userAgent = _globalWindow2['default'].navigator.userAgent;
|
|
// Seems to be broken in Chromium/Chrome && Safari in Leopard
|
|
if (/Android/.test(userAgent) || !/Chrome|Mac OS X 10.5/.test(userAgent)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Request to enter fullscreen
|
|
*
|
|
* @method enterFullScreen
|
|
*/
|
|
|
|
Html5.prototype.enterFullScreen = function enterFullScreen() {
|
|
var video = this.el_;
|
|
|
|
if ('webkitDisplayingFullscreen' in video) {
|
|
this.one('webkitbeginfullscreen', function () {
|
|
this.one('webkitendfullscreen', function () {
|
|
this.trigger('fullscreenchange', { isFullscreen: false });
|
|
});
|
|
|
|
this.trigger('fullscreenchange', { isFullscreen: true });
|
|
});
|
|
}
|
|
|
|
if (video.paused && video.networkState <= video.HAVE_METADATA) {
|
|
// attempt to prime the video element for programmatic access
|
|
// this isn't necessary on the desktop but shouldn't hurt
|
|
this.el_.play();
|
|
|
|
// playing and pausing synchronously during the transition to fullscreen
|
|
// can get iOS ~6.1 devices into a play/pause loop
|
|
this.setTimeout(function () {
|
|
video.pause();
|
|
video.webkitEnterFullScreen();
|
|
}, 0);
|
|
} else {
|
|
video.webkitEnterFullScreen();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Request to exit fullscreen
|
|
*
|
|
* @method exitFullScreen
|
|
*/
|
|
|
|
Html5.prototype.exitFullScreen = function exitFullScreen() {
|
|
this.el_.webkitExitFullScreen();
|
|
};
|
|
|
|
/**
|
|
* Get/set video
|
|
*
|
|
* @param {Object=} src Source object
|
|
* @return {Object}
|
|
* @method src
|
|
*/
|
|
|
|
Html5.prototype.src = function src(_src) {
|
|
if (_src === undefined) {
|
|
return this.el_.src;
|
|
} else {
|
|
// Setting src through `src` instead of `setSrc` will be deprecated
|
|
this.setSrc(_src);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Set video
|
|
*
|
|
* @param {Object} src Source object
|
|
* @deprecated
|
|
* @method setSrc
|
|
*/
|
|
|
|
Html5.prototype.setSrc = function setSrc(src) {
|
|
this.el_.src = src;
|
|
};
|
|
|
|
/**
|
|
* Load media into player
|
|
*
|
|
* @method load
|
|
*/
|
|
|
|
Html5.prototype.load = function load() {
|
|
this.el_.load();
|
|
};
|
|
|
|
/**
|
|
* Reset the tech. Removes all sources and calls `load`.
|
|
*
|
|
* @method reset
|
|
*/
|
|
|
|
Html5.prototype.reset = function reset() {
|
|
Html5.resetMediaElement(this.el_);
|
|
};
|
|
|
|
/**
|
|
* Get current source
|
|
*
|
|
* @return {Object}
|
|
* @method currentSrc
|
|
*/
|
|
|
|
Html5.prototype.currentSrc = function currentSrc() {
|
|
if (this.currentSource_) {
|
|
return this.currentSource_.src;
|
|
} else {
|
|
return this.el_.currentSrc;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get poster
|
|
*
|
|
* @return {String}
|
|
* @method poster
|
|
*/
|
|
|
|
Html5.prototype.poster = function poster() {
|
|
return this.el_.poster;
|
|
};
|
|
|
|
/**
|
|
* Set poster
|
|
*
|
|
* @param {String} val URL to poster image
|
|
* @method
|
|
*/
|
|
|
|
Html5.prototype.setPoster = function setPoster(val) {
|
|
this.el_.poster = val;
|
|
};
|
|
|
|
/**
|
|
* Get preload attribute
|
|
*
|
|
* @return {String}
|
|
* @method preload
|
|
*/
|
|
|
|
Html5.prototype.preload = function preload() {
|
|
return this.el_.preload;
|
|
};
|
|
|
|
/**
|
|
* Set preload attribute
|
|
*
|
|
* @param {String} val Value for preload attribute
|
|
* @method setPreload
|
|
*/
|
|
|
|
Html5.prototype.setPreload = function setPreload(val) {
|
|
this.el_.preload = val;
|
|
};
|
|
|
|
/**
|
|
* Get autoplay attribute
|
|
*
|
|
* @return {String}
|
|
* @method autoplay
|
|
*/
|
|
|
|
Html5.prototype.autoplay = function autoplay() {
|
|
return this.el_.autoplay;
|
|
};
|
|
|
|
/**
|
|
* Set autoplay attribute
|
|
*
|
|
* @param {String} val Value for preload attribute
|
|
* @method setAutoplay
|
|
*/
|
|
|
|
Html5.prototype.setAutoplay = function setAutoplay(val) {
|
|
this.el_.autoplay = val;
|
|
};
|
|
|
|
/**
|
|
* Get controls attribute
|
|
*
|
|
* @return {String}
|
|
* @method controls
|
|
*/
|
|
|
|
Html5.prototype.controls = function controls() {
|
|
return this.el_.controls;
|
|
};
|
|
|
|
/**
|
|
* Set controls attribute
|
|
*
|
|
* @param {String} val Value for controls attribute
|
|
* @method setControls
|
|
*/
|
|
|
|
Html5.prototype.setControls = function setControls(val) {
|
|
this.el_.controls = !!val;
|
|
};
|
|
|
|
/**
|
|
* Get loop attribute
|
|
*
|
|
* @return {String}
|
|
* @method loop
|
|
*/
|
|
|
|
Html5.prototype.loop = function loop() {
|
|
return this.el_.loop;
|
|
};
|
|
|
|
/**
|
|
* Set loop attribute
|
|
*
|
|
* @param {String} val Value for loop attribute
|
|
* @method setLoop
|
|
*/
|
|
|
|
Html5.prototype.setLoop = function setLoop(val) {
|
|
this.el_.loop = val;
|
|
};
|
|
|
|
/**
|
|
* Get error value
|
|
*
|
|
* @return {String}
|
|
* @method error
|
|
*/
|
|
|
|
Html5.prototype.error = function error() {
|
|
return this.el_.error;
|
|
};
|
|
|
|
/**
|
|
* Get whether or not the player is in the "seeking" state
|
|
*
|
|
* @return {Boolean}
|
|
* @method seeking
|
|
*/
|
|
|
|
Html5.prototype.seeking = function seeking() {
|
|
return this.el_.seeking;
|
|
};
|
|
|
|
/**
|
|
* Get a TimeRanges object that represents the
|
|
* ranges of the media resource to which it is possible
|
|
* for the user agent to seek.
|
|
*
|
|
* @return {TimeRangeObject}
|
|
* @method seekable
|
|
*/
|
|
|
|
Html5.prototype.seekable = function seekable() {
|
|
return this.el_.seekable;
|
|
};
|
|
|
|
/**
|
|
* Get if video ended
|
|
*
|
|
* @return {Boolean}
|
|
* @method ended
|
|
*/
|
|
|
|
Html5.prototype.ended = function ended() {
|
|
return this.el_.ended;
|
|
};
|
|
|
|
/**
|
|
* Get the value of the muted content attribute
|
|
* This attribute has no dynamic effect, it only
|
|
* controls the default state of the element
|
|
*
|
|
* @return {Boolean}
|
|
* @method defaultMuted
|
|
*/
|
|
|
|
Html5.prototype.defaultMuted = function defaultMuted() {
|
|
return this.el_.defaultMuted;
|
|
};
|
|
|
|
/**
|
|
* Get desired speed at which the media resource is to play
|
|
*
|
|
* @return {Number}
|
|
* @method playbackRate
|
|
*/
|
|
|
|
Html5.prototype.playbackRate = function playbackRate() {
|
|
return this.el_.playbackRate;
|
|
};
|
|
|
|
/**
|
|
* Returns a TimeRanges object that represents the ranges of the
|
|
* media resource that the user agent has played.
|
|
* @return {TimeRangeObject} the range of points on the media
|
|
* timeline that has been reached through normal playback
|
|
* @see https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-played
|
|
*/
|
|
|
|
Html5.prototype.played = function played() {
|
|
return this.el_.played;
|
|
};
|
|
|
|
/**
|
|
* Set desired speed at which the media resource is to play
|
|
*
|
|
* @param {Number} val Speed at which the media resource is to play
|
|
* @method setPlaybackRate
|
|
*/
|
|
|
|
Html5.prototype.setPlaybackRate = function setPlaybackRate(val) {
|
|
this.el_.playbackRate = val;
|
|
};
|
|
|
|
/**
|
|
* Get the current state of network activity for the element, from
|
|
* the list below
|
|
* NETWORK_EMPTY (numeric value 0)
|
|
* NETWORK_IDLE (numeric value 1)
|
|
* NETWORK_LOADING (numeric value 2)
|
|
* NETWORK_NO_SOURCE (numeric value 3)
|
|
*
|
|
* @return {Number}
|
|
* @method networkState
|
|
*/
|
|
|
|
Html5.prototype.networkState = function networkState() {
|
|
return this.el_.networkState;
|
|
};
|
|
|
|
/**
|
|
* Get a value that expresses the current state of the element
|
|
* with respect to rendering the current playback position, from
|
|
* the codes in the list below
|
|
* HAVE_NOTHING (numeric value 0)
|
|
* HAVE_METADATA (numeric value 1)
|
|
* HAVE_CURRENT_DATA (numeric value 2)
|
|
* HAVE_FUTURE_DATA (numeric value 3)
|
|
* HAVE_ENOUGH_DATA (numeric value 4)
|
|
*
|
|
* @return {Number}
|
|
* @method readyState
|
|
*/
|
|
|
|
Html5.prototype.readyState = function readyState() {
|
|
return this.el_.readyState;
|
|
};
|
|
|
|
/**
|
|
* Get width of video
|
|
*
|
|
* @return {Number}
|
|
* @method videoWidth
|
|
*/
|
|
|
|
Html5.prototype.videoWidth = function videoWidth() {
|
|
return this.el_.videoWidth;
|
|
};
|
|
|
|
/**
|
|
* Get height of video
|
|
*
|
|
* @return {Number}
|
|
* @method videoHeight
|
|
*/
|
|
|
|
Html5.prototype.videoHeight = function videoHeight() {
|
|
return this.el_.videoHeight;
|
|
};
|
|
|
|
/**
|
|
* Get text tracks
|
|
*
|
|
* @return {TextTrackList}
|
|
* @method textTracks
|
|
*/
|
|
|
|
Html5.prototype.textTracks = function textTracks() {
|
|
return _Tech.prototype.textTracks.call(this);
|
|
};
|
|
|
|
/**
|
|
* Creates and returns a text track object
|
|
*
|
|
* @param {String} kind Text track kind (subtitles, captions, descriptions
|
|
* chapters and metadata)
|
|
* @param {String=} label Label to identify the text track
|
|
* @param {String=} language Two letter language abbreviation
|
|
* @return {TextTrackObject}
|
|
* @method addTextTrack
|
|
*/
|
|
|
|
Html5.prototype.addTextTrack = function addTextTrack(kind, label, language) {
|
|
if (!this['featuresNativeTextTracks']) {
|
|
return _Tech.prototype.addTextTrack.call(this, kind, label, language);
|
|
}
|
|
|
|
return this.el_.addTextTrack(kind, label, language);
|
|
};
|
|
|
|
/**
|
|
* Creates a remote text track object and returns a html track element
|
|
*
|
|
* @param {Object} options The object should contain values for
|
|
* kind, language, label and src (location of the WebVTT file)
|
|
* @return {HTMLTrackElement}
|
|
* @method addRemoteTextTrack
|
|
*/
|
|
|
|
Html5.prototype.addRemoteTextTrack = function addRemoteTextTrack() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
if (!this['featuresNativeTextTracks']) {
|
|
return _Tech.prototype.addRemoteTextTrack.call(this, options);
|
|
}
|
|
|
|
var htmlTrackElement = _globalDocument2['default'].createElement('track');
|
|
|
|
if (options.kind) {
|
|
htmlTrackElement.kind = options.kind;
|
|
}
|
|
if (options.label) {
|
|
htmlTrackElement.label = options.label;
|
|
}
|
|
if (options.language || options.srclang) {
|
|
htmlTrackElement.srclang = options.language || options.srclang;
|
|
}
|
|
if (options['default']) {
|
|
htmlTrackElement['default'] = options['default'];
|
|
}
|
|
if (options.id) {
|
|
htmlTrackElement.id = options.id;
|
|
}
|
|
if (options.src) {
|
|
htmlTrackElement.src = options.src;
|
|
}
|
|
|
|
this.el().appendChild(htmlTrackElement);
|
|
|
|
// store HTMLTrackElement and TextTrack to remote list
|
|
this.remoteTextTrackEls().addTrackElement_(htmlTrackElement);
|
|
this.remoteTextTracks().addTrack_(htmlTrackElement.track);
|
|
|
|
return htmlTrackElement;
|
|
};
|
|
|
|
/**
|
|
* Remove remote text track from TextTrackList object
|
|
*
|
|
* @param {TextTrackObject} track Texttrack object to remove
|
|
* @method removeRemoteTextTrack
|
|
*/
|
|
|
|
Html5.prototype.removeRemoteTextTrack = function removeRemoteTextTrack(track) {
|
|
if (!this['featuresNativeTextTracks']) {
|
|
return _Tech.prototype.removeRemoteTextTrack.call(this, track);
|
|
}
|
|
|
|
var tracks = undefined,
|
|
i = undefined;
|
|
|
|
var trackElement = this.remoteTextTrackEls().getTrackElementByTrack_(track);
|
|
|
|
// remove HTMLTrackElement and TextTrack from remote list
|
|
this.remoteTextTrackEls().removeTrackElement_(trackElement);
|
|
this.remoteTextTracks().removeTrack_(track);
|
|
|
|
tracks = this.$$('track');
|
|
|
|
i = tracks.length;
|
|
while (i--) {
|
|
if (track === tracks[i] || track === tracks[i].track) {
|
|
this.el().removeChild(tracks[i]);
|
|
}
|
|
}
|
|
};
|
|
|
|
return Html5;
|
|
})(_techJs2['default']);
|
|
|
|
Html5.TEST_VID = _globalDocument2['default'].createElement('video');
|
|
var track = _globalDocument2['default'].createElement('track');
|
|
track.kind = 'captions';
|
|
track.srclang = 'en';
|
|
track.label = 'English';
|
|
Html5.TEST_VID.appendChild(track);
|
|
|
|
/*
|
|
* Check if HTML5 video is supported by this browser/device
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.isSupported = function () {
|
|
// IE9 with no Media Player is a LIAR! (#984)
|
|
try {
|
|
Html5.TEST_VID['volume'] = 0.5;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
|
|
return !!Html5.TEST_VID.canPlayType;
|
|
};
|
|
|
|
// Add Source Handler pattern functions to this tech
|
|
_techJs2['default'].withSourceHandlers(Html5);
|
|
|
|
/*
|
|
* The default native source handler.
|
|
* This simply passes the source to the video element. Nothing fancy.
|
|
*
|
|
* @param {Object} source The source object
|
|
* @param {Html5} tech The instance of the HTML5 tech
|
|
*/
|
|
Html5.nativeSourceHandler = {};
|
|
|
|
/*
|
|
* Check if the video element can play the given videotype
|
|
*
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Html5.nativeSourceHandler.canPlayType = function (type) {
|
|
// IE9 on Windows 7 without MediaPlayer throws an error here
|
|
// https://github.com/videojs/video.js/issues/519
|
|
try {
|
|
return Html5.TEST_VID.canPlayType(type);
|
|
} catch (e) {
|
|
return '';
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Check if the video element can handle the source natively
|
|
*
|
|
* @param {Object} source The source object
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
Html5.nativeSourceHandler.canHandleSource = function (source) {
|
|
var match, ext;
|
|
|
|
// If a type was provided we should rely on that
|
|
if (source.type) {
|
|
return Html5.nativeSourceHandler.canPlayType(source.type);
|
|
} else if (source.src) {
|
|
// If no type, fall back to checking 'video/[EXTENSION]'
|
|
ext = Url.getFileExtension(source.src);
|
|
|
|
return Html5.nativeSourceHandler.canPlayType('video/' + ext);
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/*
|
|
* Pass the source to the video element
|
|
* Adaptive source handlers will have more complicated workflows before passing
|
|
* video data to the video element
|
|
*
|
|
* @param {Object} source The source object
|
|
* @param {Html5} tech The instance of the Html5 tech
|
|
* @param {Object} options The options to pass to the source
|
|
*/
|
|
Html5.nativeSourceHandler.handleSource = function (source, tech, options) {
|
|
tech.setSrc(source.src);
|
|
};
|
|
|
|
/*
|
|
* Clean up the source handler when disposing the player or switching sources..
|
|
* (no cleanup is needed when supporting the format natively)
|
|
*/
|
|
Html5.nativeSourceHandler.dispose = function () {};
|
|
|
|
// Register the native source handler
|
|
Html5.registerSourceHandler(Html5.nativeSourceHandler);
|
|
|
|
/*
|
|
* Check if the volume can be changed in this browser/device.
|
|
* Volume cannot be changed in a lot of mobile devices.
|
|
* Specifically, it can't be changed from 1 on iOS.
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.canControlVolume = function () {
|
|
var volume = Html5.TEST_VID.volume;
|
|
Html5.TEST_VID.volume = volume / 2 + 0.1;
|
|
return volume !== Html5.TEST_VID.volume;
|
|
};
|
|
|
|
/*
|
|
* Check if playbackRate is supported in this browser/device.
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.canControlPlaybackRate = function () {
|
|
// Playback rate API is implemented in Android Chrome, but doesn't do anything
|
|
// https://github.com/videojs/video.js/issues/3180
|
|
if (browser.IS_ANDROID && browser.IS_CHROME) {
|
|
return false;
|
|
}
|
|
var playbackRate = Html5.TEST_VID.playbackRate;
|
|
Html5.TEST_VID.playbackRate = playbackRate / 2 + 0.1;
|
|
return playbackRate !== Html5.TEST_VID.playbackRate;
|
|
};
|
|
|
|
/*
|
|
* Check to see if native text tracks are supported by this browser/device
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.supportsNativeTextTracks = function () {
|
|
var supportsTextTracks;
|
|
|
|
// Figure out native text track support
|
|
// If mode is a number, we cannot change it because it'll disappear from view.
|
|
// Browsers with numeric modes include IE10 and older (<=2013) samsung android models.
|
|
// Firefox isn't playing nice either with modifying the mode
|
|
// TODO: Investigate firefox: https://github.com/videojs/video.js/issues/1862
|
|
supportsTextTracks = !!Html5.TEST_VID.textTracks;
|
|
if (supportsTextTracks && Html5.TEST_VID.textTracks.length > 0) {
|
|
supportsTextTracks = typeof Html5.TEST_VID.textTracks[0]['mode'] !== 'number';
|
|
}
|
|
if (supportsTextTracks && browser.IS_FIREFOX) {
|
|
supportsTextTracks = false;
|
|
}
|
|
if (supportsTextTracks && !('onremovetrack' in Html5.TEST_VID.textTracks)) {
|
|
supportsTextTracks = false;
|
|
}
|
|
|
|
return supportsTextTracks;
|
|
};
|
|
|
|
/*
|
|
* Check to see if native video tracks are supported by this browser/device
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.supportsNativeVideoTracks = function () {
|
|
var supportsVideoTracks = !!Html5.TEST_VID.videoTracks;
|
|
return supportsVideoTracks;
|
|
};
|
|
|
|
/*
|
|
* Check to see if native audio tracks are supported by this browser/device
|
|
*
|
|
* @return {Boolean}
|
|
*/
|
|
Html5.supportsNativeAudioTracks = function () {
|
|
var supportsAudioTracks = !!Html5.TEST_VID.audioTracks;
|
|
return supportsAudioTracks;
|
|
};
|
|
|
|
/**
|
|
* An array of events available on the Html5 tech.
|
|
*
|
|
* @private
|
|
* @type {Array}
|
|
*/
|
|
Html5.Events = ['loadstart', 'suspend', 'abort', 'error', 'emptied', 'stalled', 'loadedmetadata', 'loadeddata', 'canplay', 'canplaythrough', 'playing', 'waiting', 'seeking', 'seeked', 'ended', 'durationchange', 'timeupdate', 'progress', 'play', 'pause', 'ratechange', 'volumechange'];
|
|
|
|
/*
|
|
* Set the tech's volume control support status
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['featuresVolumeControl'] = Html5.canControlVolume();
|
|
|
|
/*
|
|
* Set the tech's playbackRate support status
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['featuresPlaybackRate'] = Html5.canControlPlaybackRate();
|
|
|
|
/*
|
|
* Set the tech's status on moving the video element.
|
|
* In iOS, if you move a video element in the DOM, it breaks video playback.
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['movingMediaElementInDOM'] = !browser.IS_IOS;
|
|
|
|
/*
|
|
* Set the the tech's fullscreen resize support status.
|
|
* HTML video is able to automatically resize when going to fullscreen.
|
|
* (No longer appears to be used. Can probably be removed.)
|
|
*/
|
|
Html5.prototype['featuresFullscreenResize'] = true;
|
|
|
|
/*
|
|
* Set the tech's progress event support status
|
|
* (this disables the manual progress events of the Tech)
|
|
*/
|
|
Html5.prototype['featuresProgressEvents'] = true;
|
|
|
|
/*
|
|
* Sets the tech's status on native text track support
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['featuresNativeTextTracks'] = Html5.supportsNativeTextTracks();
|
|
|
|
/**
|
|
* Sets the tech's status on native text track support
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['featuresNativeVideoTracks'] = Html5.supportsNativeVideoTracks();
|
|
|
|
/**
|
|
* Sets the tech's status on native audio track support
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
Html5.prototype['featuresNativeAudioTracks'] = Html5.supportsNativeAudioTracks();
|
|
|
|
// HTML5 Feature detection and Device Fixes --------------------------------- //
|
|
var canPlayType = undefined;
|
|
var mpegurlRE = /^application\/(?:x-|vnd\.apple\.)mpegurl/i;
|
|
var mp4RE = /^video\/mp4/i;
|
|
|
|
Html5.patchCanPlayType = function () {
|
|
// Android 4.0 and above can play HLS to some extent but it reports being unable to do so
|
|
if (browser.ANDROID_VERSION >= 4.0) {
|
|
if (!canPlayType) {
|
|
canPlayType = Html5.TEST_VID.constructor.prototype.canPlayType;
|
|
}
|
|
|
|
Html5.TEST_VID.constructor.prototype.canPlayType = function (type) {
|
|
if (type && mpegurlRE.test(type)) {
|
|
return 'maybe';
|
|
}
|
|
return canPlayType.call(this, type);
|
|
};
|
|
}
|
|
|
|
// Override Android 2.2 and less canPlayType method which is broken
|
|
if (browser.IS_OLD_ANDROID) {
|
|
if (!canPlayType) {
|
|
canPlayType = Html5.TEST_VID.constructor.prototype.canPlayType;
|
|
}
|
|
|
|
Html5.TEST_VID.constructor.prototype.canPlayType = function (type) {
|
|
if (type && mp4RE.test(type)) {
|
|
return 'maybe';
|
|
}
|
|
return canPlayType.call(this, type);
|
|
};
|
|
}
|
|
};
|
|
|
|
Html5.unpatchCanPlayType = function () {
|
|
var r = Html5.TEST_VID.constructor.prototype.canPlayType;
|
|
Html5.TEST_VID.constructor.prototype.canPlayType = canPlayType;
|
|
canPlayType = null;
|
|
return r;
|
|
};
|
|
|
|
// by default, patch the video element
|
|
Html5.patchCanPlayType();
|
|
|
|
Html5.disposeMediaElement = function (el) {
|
|
if (!el) {
|
|
return;
|
|
}
|
|
|
|
if (el.parentNode) {
|
|
el.parentNode.removeChild(el);
|
|
}
|
|
|
|
// remove any child track or source nodes to prevent their loading
|
|
while (el.hasChildNodes()) {
|
|
el.removeChild(el.firstChild);
|
|
}
|
|
|
|
// remove any src reference. not setting `src=''` because that causes a warning
|
|
// in firefox
|
|
el.removeAttribute('src');
|
|
|
|
// force the media element to update its loading state by calling load()
|
|
// however IE on Windows 7N has a bug that throws an error so need a try/catch (#793)
|
|
if (typeof el.load === 'function') {
|
|
// wrapping in an iife so it's not deoptimized (#1060#discussion_r10324473)
|
|
(function () {
|
|
try {
|
|
el.load();
|
|
} catch (e) {
|
|
// not supported
|
|
}
|
|
})();
|
|
}
|
|
};
|
|
|
|
Html5.resetMediaElement = function (el) {
|
|
if (!el) {
|
|
return;
|
|
}
|
|
|
|
var sources = el.querySelectorAll('source');
|
|
var i = sources.length;
|
|
while (i--) {
|
|
el.removeChild(sources[i]);
|
|
}
|
|
|
|
// remove any src reference.
|
|
// not setting `src=''` because that throws an error
|
|
el.removeAttribute('src');
|
|
|
|
if (typeof el.load === 'function') {
|
|
// wrapping in an iife so it's not deoptimized (#1060#discussion_r10324473)
|
|
(function () {
|
|
try {
|
|
el.load();
|
|
} catch (e) {}
|
|
})();
|
|
}
|
|
};
|
|
|
|
_component2['default'].registerComponent('Html5', Html5);
|
|
_techJs2['default'].registerTech('Html5', Html5);
|
|
exports['default'] = Html5;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../../src/js/tracks/text-track.js":134,"../component":67,"../utils/browser.js":140,"../utils/dom.js":143,"../utils/fn.js":145,"../utils/log.js":148,"../utils/merge-options.js":149,"../utils/to-title-case.js":152,"../utils/url.js":153,"./tech.js":124,"global/document":1,"global/window":2,"object.assign":45,"tsml":55}],123:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file loader.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
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 _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 _componentJs = _dereq_('../component.js');
|
|
|
|
var _componentJs2 = _interopRequireDefault(_componentJs);
|
|
|
|
var _techJs = _dereq_('./tech.js');
|
|
|
|
var _techJs2 = _interopRequireDefault(_techJs);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _utilsToTitleCaseJs = _dereq_('../utils/to-title-case.js');
|
|
|
|
var _utilsToTitleCaseJs2 = _interopRequireDefault(_utilsToTitleCaseJs);
|
|
|
|
/**
|
|
* The Media Loader is the component that decides which playback technology to load
|
|
* when the player is initialized.
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Component
|
|
* @class MediaLoader
|
|
*/
|
|
|
|
var MediaLoader = (function (_Component) {
|
|
_inherits(MediaLoader, _Component);
|
|
|
|
function MediaLoader(player, options, ready) {
|
|
_classCallCheck(this, MediaLoader);
|
|
|
|
_Component.call(this, player, options, ready);
|
|
|
|
// If there are no sources when the player is initialized,
|
|
// load the first supported playback technology.
|
|
|
|
if (!options.playerOptions['sources'] || options.playerOptions['sources'].length === 0) {
|
|
for (var i = 0, j = options.playerOptions['techOrder']; i < j.length; i++) {
|
|
var techName = _utilsToTitleCaseJs2['default'](j[i]);
|
|
var tech = _techJs2['default'].getTech(techName);
|
|
// Support old behavior of techs being registered as components.
|
|
// Remove once that deprecated behavior is removed.
|
|
if (!techName) {
|
|
tech = _componentJs2['default'].getComponent(techName);
|
|
}
|
|
|
|
// Check if the browser supports this technology
|
|
if (tech && tech.isSupported()) {
|
|
player.loadTech_(techName);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
// // Loop through playback technologies (HTML5, Flash) and check for support.
|
|
// // Then load the best source.
|
|
// // A few assumptions here:
|
|
// // All playback technologies respect preload false.
|
|
player.src(options.playerOptions['sources']);
|
|
}
|
|
}
|
|
|
|
return MediaLoader;
|
|
})(_componentJs2['default']);
|
|
|
|
_componentJs2['default'].registerComponent('MediaLoader', MediaLoader);
|
|
exports['default'] = MediaLoader;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component.js":67,"../utils/to-title-case.js":152,"./tech.js":124,"global/window":2}],124:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file tech.js
|
|
* Media Technology Controller - Base class for media playback
|
|
* technology controllers like Flash and HTML5
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _tracksHtmlTrackElement = _dereq_('../tracks/html-track-element');
|
|
|
|
var _tracksHtmlTrackElement2 = _interopRequireDefault(_tracksHtmlTrackElement);
|
|
|
|
var _tracksHtmlTrackElementList = _dereq_('../tracks/html-track-element-list');
|
|
|
|
var _tracksHtmlTrackElementList2 = _interopRequireDefault(_tracksHtmlTrackElementList);
|
|
|
|
var _utilsMergeOptionsJs = _dereq_('../utils/merge-options.js');
|
|
|
|
var _utilsMergeOptionsJs2 = _interopRequireDefault(_utilsMergeOptionsJs);
|
|
|
|
var _tracksTextTrack = _dereq_('../tracks/text-track');
|
|
|
|
var _tracksTextTrack2 = _interopRequireDefault(_tracksTextTrack);
|
|
|
|
var _tracksTextTrackList = _dereq_('../tracks/text-track-list');
|
|
|
|
var _tracksTextTrackList2 = _interopRequireDefault(_tracksTextTrackList);
|
|
|
|
var _tracksVideoTrack = _dereq_('../tracks/video-track');
|
|
|
|
var _tracksVideoTrack2 = _interopRequireDefault(_tracksVideoTrack);
|
|
|
|
var _tracksVideoTrackList = _dereq_('../tracks/video-track-list');
|
|
|
|
var _tracksVideoTrackList2 = _interopRequireDefault(_tracksVideoTrackList);
|
|
|
|
var _tracksAudioTrackList = _dereq_('../tracks/audio-track-list');
|
|
|
|
var _tracksAudioTrackList2 = _interopRequireDefault(_tracksAudioTrackList);
|
|
|
|
var _tracksAudioTrack = _dereq_('../tracks/audio-track');
|
|
|
|
var _tracksAudioTrack2 = _interopRequireDefault(_tracksAudioTrack);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsLogJs = _dereq_('../utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _utilsTimeRangesJs = _dereq_('../utils/time-ranges.js');
|
|
|
|
var _utilsBufferJs = _dereq_('../utils/buffer.js');
|
|
|
|
var _mediaErrorJs = _dereq_('../media-error.js');
|
|
|
|
var _mediaErrorJs2 = _interopRequireDefault(_mediaErrorJs);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* Base class for media (HTML5 Video, Flash) controllers
|
|
*
|
|
* @param {Object=} options Options object
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Component
|
|
* @class Tech
|
|
*/
|
|
|
|
var Tech = (function (_Component) {
|
|
_inherits(Tech, _Component);
|
|
|
|
function Tech() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
var ready = arguments.length <= 1 || arguments[1] === undefined ? function () {} : arguments[1];
|
|
|
|
_classCallCheck(this, Tech);
|
|
|
|
// we don't want the tech to report user activity automatically.
|
|
// This is done manually in addControlsListeners
|
|
options.reportTouchActivity = false;
|
|
_Component.call(this, null, options, ready);
|
|
|
|
// keep track of whether the current source has played at all to
|
|
// implement a very limited played()
|
|
this.hasStarted_ = false;
|
|
this.on('playing', function () {
|
|
this.hasStarted_ = true;
|
|
});
|
|
this.on('loadstart', function () {
|
|
this.hasStarted_ = false;
|
|
});
|
|
|
|
this.textTracks_ = options.textTracks;
|
|
this.videoTracks_ = options.videoTracks;
|
|
this.audioTracks_ = options.audioTracks;
|
|
|
|
// Manually track progress in cases where the browser/flash player doesn't report it.
|
|
if (!this.featuresProgressEvents) {
|
|
this.manualProgressOn();
|
|
}
|
|
|
|
// Manually track timeupdates in cases where the browser/flash player doesn't report it.
|
|
if (!this.featuresTimeupdateEvents) {
|
|
this.manualTimeUpdatesOn();
|
|
}
|
|
|
|
if (options.nativeCaptions === false || options.nativeTextTracks === false) {
|
|
this.featuresNativeTextTracks = false;
|
|
}
|
|
|
|
if (!this.featuresNativeTextTracks) {
|
|
this.on('ready', this.emulateTextTracks);
|
|
}
|
|
|
|
this.initTextTrackListeners();
|
|
this.initTrackListeners();
|
|
|
|
// Turn on component tap events
|
|
this.emitTapEvents();
|
|
}
|
|
|
|
/**
|
|
* List of associated text tracks
|
|
*
|
|
* @type {TextTrackList}
|
|
* @private
|
|
*/
|
|
|
|
/* Fallbacks for unsupported event types
|
|
================================================================================ */
|
|
// Manually trigger progress events based on changes to the buffered amount
|
|
// Many flash players and older HTML5 browsers don't send progress or progress-like events
|
|
/**
|
|
* Turn on progress events
|
|
*
|
|
* @method manualProgressOn
|
|
*/
|
|
|
|
Tech.prototype.manualProgressOn = function manualProgressOn() {
|
|
this.on('durationchange', this.onDurationChange);
|
|
|
|
this.manualProgress = true;
|
|
|
|
// Trigger progress watching when a source begins loading
|
|
this.one('ready', this.trackProgress);
|
|
};
|
|
|
|
/**
|
|
* Turn off progress events
|
|
*
|
|
* @method manualProgressOff
|
|
*/
|
|
|
|
Tech.prototype.manualProgressOff = function manualProgressOff() {
|
|
this.manualProgress = false;
|
|
this.stopTrackingProgress();
|
|
|
|
this.off('durationchange', this.onDurationChange);
|
|
};
|
|
|
|
/**
|
|
* Track progress
|
|
*
|
|
* @method trackProgress
|
|
*/
|
|
|
|
Tech.prototype.trackProgress = function trackProgress() {
|
|
this.stopTrackingProgress();
|
|
this.progressInterval = this.setInterval(Fn.bind(this, function () {
|
|
// Don't trigger unless buffered amount is greater than last time
|
|
|
|
var numBufferedPercent = this.bufferedPercent();
|
|
|
|
if (this.bufferedPercent_ !== numBufferedPercent) {
|
|
this.trigger('progress');
|
|
}
|
|
|
|
this.bufferedPercent_ = numBufferedPercent;
|
|
|
|
if (numBufferedPercent === 1) {
|
|
this.stopTrackingProgress();
|
|
}
|
|
}), 500);
|
|
};
|
|
|
|
/**
|
|
* Update duration
|
|
*
|
|
* @method onDurationChange
|
|
*/
|
|
|
|
Tech.prototype.onDurationChange = function onDurationChange() {
|
|
this.duration_ = this.duration();
|
|
};
|
|
|
|
/**
|
|
* Create and get TimeRange object for buffering
|
|
*
|
|
* @return {TimeRangeObject}
|
|
* @method buffered
|
|
*/
|
|
|
|
Tech.prototype.buffered = function buffered() {
|
|
return _utilsTimeRangesJs.createTimeRange(0, 0);
|
|
};
|
|
|
|
/**
|
|
* Get buffered percent
|
|
*
|
|
* @return {Number}
|
|
* @method bufferedPercent
|
|
*/
|
|
|
|
Tech.prototype.bufferedPercent = function bufferedPercent() {
|
|
return _utilsBufferJs.bufferedPercent(this.buffered(), this.duration_);
|
|
};
|
|
|
|
/**
|
|
* Stops tracking progress by clearing progress interval
|
|
*
|
|
* @method stopTrackingProgress
|
|
*/
|
|
|
|
Tech.prototype.stopTrackingProgress = function stopTrackingProgress() {
|
|
this.clearInterval(this.progressInterval);
|
|
};
|
|
|
|
/*! Time Tracking -------------------------------------------------------------- */
|
|
/**
|
|
* Set event listeners for on play and pause and tracking current time
|
|
*
|
|
* @method manualTimeUpdatesOn
|
|
*/
|
|
|
|
Tech.prototype.manualTimeUpdatesOn = function manualTimeUpdatesOn() {
|
|
this.manualTimeUpdates = true;
|
|
|
|
this.on('play', this.trackCurrentTime);
|
|
this.on('pause', this.stopTrackingCurrentTime);
|
|
};
|
|
|
|
/**
|
|
* Remove event listeners for on play and pause and tracking current time
|
|
*
|
|
* @method manualTimeUpdatesOff
|
|
*/
|
|
|
|
Tech.prototype.manualTimeUpdatesOff = function manualTimeUpdatesOff() {
|
|
this.manualTimeUpdates = false;
|
|
this.stopTrackingCurrentTime();
|
|
this.off('play', this.trackCurrentTime);
|
|
this.off('pause', this.stopTrackingCurrentTime);
|
|
};
|
|
|
|
/**
|
|
* Tracks current time
|
|
*
|
|
* @method trackCurrentTime
|
|
*/
|
|
|
|
Tech.prototype.trackCurrentTime = function trackCurrentTime() {
|
|
if (this.currentTimeInterval) {
|
|
this.stopTrackingCurrentTime();
|
|
}
|
|
this.currentTimeInterval = this.setInterval(function () {
|
|
this.trigger({ type: 'timeupdate', target: this, manuallyTriggered: true });
|
|
}, 250); // 42 = 24 fps // 250 is what Webkit uses // FF uses 15
|
|
};
|
|
|
|
/**
|
|
* Turn off play progress tracking (when paused or dragging)
|
|
*
|
|
* @method stopTrackingCurrentTime
|
|
*/
|
|
|
|
Tech.prototype.stopTrackingCurrentTime = function stopTrackingCurrentTime() {
|
|
this.clearInterval(this.currentTimeInterval);
|
|
|
|
// #1002 - if the video ends right before the next timeupdate would happen,
|
|
// the progress bar won't make it all the way to the end
|
|
this.trigger({ type: 'timeupdate', target: this, manuallyTriggered: true });
|
|
};
|
|
|
|
/**
|
|
* Turn off any manual progress or timeupdate tracking
|
|
*
|
|
* @method dispose
|
|
*/
|
|
|
|
Tech.prototype.dispose = function dispose() {
|
|
|
|
// clear out all tracks because we can't reuse them between techs
|
|
this.clearTracks(['audio', 'video', 'text']);
|
|
|
|
// Turn off any manual progress or timeupdate tracking
|
|
if (this.manualProgress) {
|
|
this.manualProgressOff();
|
|
}
|
|
|
|
if (this.manualTimeUpdates) {
|
|
this.manualTimeUpdatesOff();
|
|
}
|
|
|
|
_Component.prototype.dispose.call(this);
|
|
};
|
|
|
|
/**
|
|
* clear out a track list, or multiple track lists
|
|
*
|
|
* Note: Techs without source handlers should call this between
|
|
* sources for video & audio tracks, as usually you don't want
|
|
* to use them between tracks and we have no automatic way to do
|
|
* it for you
|
|
*
|
|
* @method clearTracks
|
|
* @param {Array|String} types type(s) of track lists to empty
|
|
*/
|
|
|
|
Tech.prototype.clearTracks = function clearTracks(types) {
|
|
var _this = this;
|
|
|
|
types = [].concat(types);
|
|
// clear out all tracks because we can't reuse them between techs
|
|
types.forEach(function (type) {
|
|
var list = _this[type + 'Tracks']() || [];
|
|
var i = list.length;
|
|
while (i--) {
|
|
var track = list[i];
|
|
if (type === 'text') {
|
|
_this.removeRemoteTextTrack(track);
|
|
}
|
|
list.removeTrack_(track);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Reset the tech. Removes all sources and resets readyState.
|
|
*
|
|
* @method reset
|
|
*/
|
|
|
|
Tech.prototype.reset = function reset() {};
|
|
|
|
/**
|
|
* When invoked without an argument, returns a MediaError object
|
|
* representing the current error state of the player or null if
|
|
* there is no error. When invoked with an argument, set the current
|
|
* error state of the player.
|
|
* @param {MediaError=} err Optional an error object
|
|
* @return {MediaError} the current error object or null
|
|
* @method error
|
|
*/
|
|
|
|
Tech.prototype.error = function error(err) {
|
|
if (err !== undefined) {
|
|
if (err instanceof _mediaErrorJs2['default']) {
|
|
this.error_ = err;
|
|
} else {
|
|
this.error_ = new _mediaErrorJs2['default'](err);
|
|
}
|
|
this.trigger('error');
|
|
}
|
|
return this.error_;
|
|
};
|
|
|
|
/**
|
|
* Return the time ranges that have been played through for the
|
|
* current source. This implementation is incomplete. It does not
|
|
* track the played time ranges, only whether the source has played
|
|
* at all or not.
|
|
* @return {TimeRangeObject} a single time range if this video has
|
|
* played or an empty set of ranges if not.
|
|
* @method played
|
|
*/
|
|
|
|
Tech.prototype.played = function played() {
|
|
if (this.hasStarted_) {
|
|
return _utilsTimeRangesJs.createTimeRange(0, 0);
|
|
}
|
|
return _utilsTimeRangesJs.createTimeRange();
|
|
};
|
|
|
|
/**
|
|
* Set current time
|
|
*
|
|
* @method setCurrentTime
|
|
*/
|
|
|
|
Tech.prototype.setCurrentTime = function setCurrentTime() {
|
|
// improve the accuracy of manual timeupdates
|
|
if (this.manualTimeUpdates) {
|
|
this.trigger({ type: 'timeupdate', target: this, manuallyTriggered: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initialize texttrack listeners
|
|
*
|
|
* @method initTextTrackListeners
|
|
*/
|
|
|
|
Tech.prototype.initTextTrackListeners = function initTextTrackListeners() {
|
|
var textTrackListChanges = Fn.bind(this, function () {
|
|
this.trigger('texttrackchange');
|
|
});
|
|
|
|
var tracks = this.textTracks();
|
|
|
|
if (!tracks) return;
|
|
|
|
tracks.addEventListener('removetrack', textTrackListChanges);
|
|
tracks.addEventListener('addtrack', textTrackListChanges);
|
|
|
|
this.on('dispose', Fn.bind(this, function () {
|
|
tracks.removeEventListener('removetrack', textTrackListChanges);
|
|
tracks.removeEventListener('addtrack', textTrackListChanges);
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Initialize audio and video track listeners
|
|
*
|
|
* @method initTrackListeners
|
|
*/
|
|
|
|
Tech.prototype.initTrackListeners = function initTrackListeners() {
|
|
var _this2 = this;
|
|
|
|
var trackTypes = ['video', 'audio'];
|
|
|
|
trackTypes.forEach(function (type) {
|
|
var trackListChanges = function trackListChanges() {
|
|
_this2.trigger(type + 'trackchange');
|
|
};
|
|
|
|
var tracks = _this2[type + 'Tracks']();
|
|
|
|
tracks.addEventListener('removetrack', trackListChanges);
|
|
tracks.addEventListener('addtrack', trackListChanges);
|
|
|
|
_this2.on('dispose', function () {
|
|
tracks.removeEventListener('removetrack', trackListChanges);
|
|
tracks.removeEventListener('addtrack', trackListChanges);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Emulate texttracks
|
|
*
|
|
* @method emulateTextTracks
|
|
*/
|
|
|
|
Tech.prototype.emulateTextTracks = function emulateTextTracks() {
|
|
var _this3 = this;
|
|
|
|
var tracks = this.textTracks();
|
|
if (!tracks) {
|
|
return;
|
|
}
|
|
|
|
if (!_globalWindow2['default']['WebVTT'] && this.el().parentNode != null) {
|
|
(function () {
|
|
var script = _globalDocument2['default'].createElement('script');
|
|
script.src = _this3.options_['vtt.js'] || 'https://cdn.rawgit.com/gkatsev/vtt.js/vjs-v0.12.1/dist/vtt.min.js';
|
|
script.onload = function () {
|
|
_this3.trigger('vttjsloaded');
|
|
};
|
|
script.onerror = function () {
|
|
_this3.trigger('vttjserror');
|
|
};
|
|
_this3.on('dispose', function () {
|
|
script.onload = null;
|
|
script.onerror = null;
|
|
});
|
|
// but have not loaded yet and we set it to true before the inject so that
|
|
// we don't overwrite the injected window.WebVTT if it loads right away
|
|
_globalWindow2['default']['WebVTT'] = true;
|
|
_this3.el().parentNode.appendChild(script);
|
|
})();
|
|
}
|
|
|
|
var updateDisplay = function updateDisplay() {
|
|
return _this3.trigger('texttrackchange');
|
|
};
|
|
var textTracksChanges = function textTracksChanges() {
|
|
updateDisplay();
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
track.removeEventListener('cuechange', updateDisplay);
|
|
if (track.mode === 'showing') {
|
|
track.addEventListener('cuechange', updateDisplay);
|
|
}
|
|
}
|
|
};
|
|
|
|
textTracksChanges();
|
|
tracks.addEventListener('change', textTracksChanges);
|
|
|
|
this.on('dispose', function () {
|
|
tracks.removeEventListener('change', textTracksChanges);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get videotracks
|
|
*
|
|
* @returns {VideoTrackList}
|
|
* @method videoTracks
|
|
*/
|
|
|
|
Tech.prototype.videoTracks = function videoTracks() {
|
|
this.videoTracks_ = this.videoTracks_ || new _tracksVideoTrackList2['default']();
|
|
return this.videoTracks_;
|
|
};
|
|
|
|
/**
|
|
* Get audiotracklist
|
|
*
|
|
* @returns {AudioTrackList}
|
|
* @method audioTracks
|
|
*/
|
|
|
|
Tech.prototype.audioTracks = function audioTracks() {
|
|
this.audioTracks_ = this.audioTracks_ || new _tracksAudioTrackList2['default']();
|
|
return this.audioTracks_;
|
|
};
|
|
|
|
/*
|
|
* Provide default methods for text tracks.
|
|
*
|
|
* Html5 tech overrides these.
|
|
*/
|
|
|
|
/**
|
|
* Get texttracks
|
|
*
|
|
* @returns {TextTrackList}
|
|
* @method textTracks
|
|
*/
|
|
|
|
Tech.prototype.textTracks = function textTracks() {
|
|
this.textTracks_ = this.textTracks_ || new _tracksTextTrackList2['default']();
|
|
return this.textTracks_;
|
|
};
|
|
|
|
/**
|
|
* Get remote texttracks
|
|
*
|
|
* @returns {TextTrackList}
|
|
* @method remoteTextTracks
|
|
*/
|
|
|
|
Tech.prototype.remoteTextTracks = function remoteTextTracks() {
|
|
this.remoteTextTracks_ = this.remoteTextTracks_ || new _tracksTextTrackList2['default']();
|
|
return this.remoteTextTracks_;
|
|
};
|
|
|
|
/**
|
|
* Get remote htmltrackelements
|
|
*
|
|
* @returns {HTMLTrackElementList}
|
|
* @method remoteTextTrackEls
|
|
*/
|
|
|
|
Tech.prototype.remoteTextTrackEls = function remoteTextTrackEls() {
|
|
this.remoteTextTrackEls_ = this.remoteTextTrackEls_ || new _tracksHtmlTrackElementList2['default']();
|
|
return this.remoteTextTrackEls_;
|
|
};
|
|
|
|
/**
|
|
* Creates and returns a remote text track object
|
|
*
|
|
* @param {String} kind Text track kind (subtitles, captions, descriptions
|
|
* chapters and metadata)
|
|
* @param {String=} label Label to identify the text track
|
|
* @param {String=} language Two letter language abbreviation
|
|
* @return {TextTrackObject}
|
|
* @method addTextTrack
|
|
*/
|
|
|
|
Tech.prototype.addTextTrack = function addTextTrack(kind, label, language) {
|
|
if (!kind) {
|
|
throw new Error('TextTrack kind is required but was not provided');
|
|
}
|
|
|
|
return createTrackHelper(this, kind, label, language);
|
|
};
|
|
|
|
/**
|
|
* Creates a remote text track object and returns a emulated html track element
|
|
*
|
|
* @param {Object} options The object should contain values for
|
|
* kind, language, label and src (location of the WebVTT file)
|
|
* @return {HTMLTrackElement}
|
|
* @method addRemoteTextTrack
|
|
*/
|
|
|
|
Tech.prototype.addRemoteTextTrack = function addRemoteTextTrack(options) {
|
|
var track = _utilsMergeOptionsJs2['default'](options, {
|
|
tech: this
|
|
});
|
|
|
|
var htmlTrackElement = new _tracksHtmlTrackElement2['default'](track);
|
|
|
|
// store HTMLTrackElement and TextTrack to remote list
|
|
this.remoteTextTrackEls().addTrackElement_(htmlTrackElement);
|
|
this.remoteTextTracks().addTrack_(htmlTrackElement.track);
|
|
|
|
// must come after remoteTextTracks()
|
|
this.textTracks().addTrack_(htmlTrackElement.track);
|
|
|
|
return htmlTrackElement;
|
|
};
|
|
|
|
/**
|
|
* Remove remote texttrack
|
|
*
|
|
* @param {TextTrackObject} track Texttrack to remove
|
|
* @method removeRemoteTextTrack
|
|
*/
|
|
|
|
Tech.prototype.removeRemoteTextTrack = function removeRemoteTextTrack(track) {
|
|
this.textTracks().removeTrack_(track);
|
|
|
|
var trackElement = this.remoteTextTrackEls().getTrackElementByTrack_(track);
|
|
|
|
// remove HTMLTrackElement and TextTrack from remote list
|
|
this.remoteTextTrackEls().removeTrackElement_(trackElement);
|
|
this.remoteTextTracks().removeTrack_(track);
|
|
};
|
|
|
|
/**
|
|
* Provide a default setPoster method for techs
|
|
* Poster support for techs should be optional, so we don't want techs to
|
|
* break if they don't have a way to set a poster.
|
|
*
|
|
* @method setPoster
|
|
*/
|
|
|
|
Tech.prototype.setPoster = function setPoster() {};
|
|
|
|
/*
|
|
* Check if the tech can support the given type
|
|
*
|
|
* The base tech does not support any type, but source handlers might
|
|
* overwrite this.
|
|
*
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
|
|
Tech.prototype.canPlayType = function canPlayType() {
|
|
return '';
|
|
};
|
|
|
|
/*
|
|
* Return whether the argument is a Tech or not.
|
|
* Can be passed either a Class like `Html5` or a instance like `player.tech_`
|
|
*
|
|
* @param {Object} component An item to check
|
|
* @return {Boolean} Whether it is a tech or not
|
|
*/
|
|
|
|
Tech.isTech = function isTech(component) {
|
|
return component.prototype instanceof Tech || component instanceof Tech || component === Tech;
|
|
};
|
|
|
|
/**
|
|
* Registers a Tech
|
|
*
|
|
* @param {String} name Name of the Tech to register
|
|
* @param {Object} tech The tech to register
|
|
* @static
|
|
* @method registerComponent
|
|
*/
|
|
|
|
Tech.registerTech = function registerTech(name, tech) {
|
|
if (!Tech.techs_) {
|
|
Tech.techs_ = {};
|
|
}
|
|
|
|
if (!Tech.isTech(tech)) {
|
|
throw new Error('Tech ' + name + ' must be a Tech');
|
|
}
|
|
|
|
Tech.techs_[name] = tech;
|
|
return tech;
|
|
};
|
|
|
|
/**
|
|
* Gets a component by name
|
|
*
|
|
* @param {String} name Name of the component to get
|
|
* @return {Component}
|
|
* @static
|
|
* @method getComponent
|
|
*/
|
|
|
|
Tech.getTech = function getTech(name) {
|
|
if (Tech.techs_ && Tech.techs_[name]) {
|
|
return Tech.techs_[name];
|
|
}
|
|
|
|
if (_globalWindow2['default'] && _globalWindow2['default'].videojs && _globalWindow2['default'].videojs[name]) {
|
|
_utilsLogJs2['default'].warn('The ' + name + ' tech was added to the videojs object when it should be registered using videojs.registerTech(name, tech)');
|
|
return _globalWindow2['default'].videojs[name];
|
|
}
|
|
};
|
|
|
|
return Tech;
|
|
})(_component2['default']);
|
|
|
|
Tech.prototype.textTracks_;
|
|
|
|
/**
|
|
* List of associated audio tracks
|
|
*
|
|
* @type {AudioTrackList}
|
|
* @private
|
|
*/
|
|
Tech.prototype.audioTracks_;
|
|
|
|
/**
|
|
* List of associated video tracks
|
|
*
|
|
* @type {VideoTrackList}
|
|
* @private
|
|
*/
|
|
Tech.prototype.videoTracks_;
|
|
|
|
var createTrackHelper = function createTrackHelper(self, kind, label, language) {
|
|
var options = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];
|
|
|
|
var tracks = self.textTracks();
|
|
|
|
options.kind = kind;
|
|
|
|
if (label) {
|
|
options.label = label;
|
|
}
|
|
if (language) {
|
|
options.language = language;
|
|
}
|
|
options.tech = self;
|
|
|
|
var track = new _tracksTextTrack2['default'](options);
|
|
tracks.addTrack_(track);
|
|
|
|
return track;
|
|
};
|
|
|
|
Tech.prototype.featuresVolumeControl = true;
|
|
|
|
// Resizing plugins using request fullscreen reloads the plugin
|
|
Tech.prototype.featuresFullscreenResize = false;
|
|
Tech.prototype.featuresPlaybackRate = false;
|
|
|
|
// Optional events that we can manually mimic with timers
|
|
// currently not triggered by video-js-swf
|
|
Tech.prototype.featuresProgressEvents = false;
|
|
Tech.prototype.featuresTimeupdateEvents = false;
|
|
|
|
Tech.prototype.featuresNativeTextTracks = false;
|
|
|
|
/*
|
|
* A functional mixin for techs that want to use the Source Handler pattern.
|
|
*
|
|
* ##### EXAMPLE:
|
|
*
|
|
* Tech.withSourceHandlers.call(MyTech);
|
|
*
|
|
*/
|
|
Tech.withSourceHandlers = function (_Tech) {
|
|
/*
|
|
* Register a source handler
|
|
* Source handlers are scripts for handling specific formats.
|
|
* The source handler pattern is used for adaptive formats (HLS, DASH) that
|
|
* manually load video data and feed it into a Source Buffer (Media Source Extensions)
|
|
* @param {Function} handler The source handler
|
|
* @param {Boolean} first Register it before any existing handlers
|
|
*/
|
|
_Tech.registerSourceHandler = function (handler, index) {
|
|
var handlers = _Tech.sourceHandlers;
|
|
|
|
if (!handlers) {
|
|
handlers = _Tech.sourceHandlers = [];
|
|
}
|
|
|
|
if (index === undefined) {
|
|
// add to the end of the list
|
|
index = handlers.length;
|
|
}
|
|
|
|
handlers.splice(index, 0, handler);
|
|
};
|
|
|
|
/*
|
|
* Check if the tech can support the given type
|
|
* @param {String} type The mimetype to check
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
_Tech.canPlayType = function (type) {
|
|
var handlers = _Tech.sourceHandlers || [];
|
|
var can = undefined;
|
|
|
|
for (var i = 0; i < handlers.length; i++) {
|
|
can = handlers[i].canPlayType(type);
|
|
|
|
if (can) {
|
|
return can;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/*
|
|
* Return the first source handler that supports the source
|
|
* TODO: Answer question: should 'probably' be prioritized over 'maybe'
|
|
* @param {Object} source The source object
|
|
* @returns {Object} The first source handler that supports the source
|
|
* @returns {null} Null if no source handler is found
|
|
*/
|
|
_Tech.selectSourceHandler = function (source) {
|
|
var handlers = _Tech.sourceHandlers || [];
|
|
var can = undefined;
|
|
|
|
for (var i = 0; i < handlers.length; i++) {
|
|
can = handlers[i].canHandleSource(source);
|
|
|
|
if (can) {
|
|
return handlers[i];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
/*
|
|
* Check if the tech can support the given source
|
|
* @param {Object} srcObj The source object
|
|
* @return {String} 'probably', 'maybe', or '' (empty string)
|
|
*/
|
|
_Tech.canPlaySource = function (srcObj) {
|
|
var sh = _Tech.selectSourceHandler(srcObj);
|
|
|
|
if (sh) {
|
|
return sh.canHandleSource(srcObj);
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
/*
|
|
* When using a source handler, prefer its implementation of
|
|
* any function normally provided by the tech.
|
|
*/
|
|
var deferrable = ['seekable', 'duration'];
|
|
|
|
deferrable.forEach(function (fnName) {
|
|
var originalFn = this[fnName];
|
|
|
|
if (typeof originalFn !== 'function') {
|
|
return;
|
|
}
|
|
|
|
this[fnName] = function () {
|
|
if (this.sourceHandler_ && this.sourceHandler_[fnName]) {
|
|
return this.sourceHandler_[fnName].apply(this.sourceHandler_, arguments);
|
|
}
|
|
return originalFn.apply(this, arguments);
|
|
};
|
|
}, _Tech.prototype);
|
|
|
|
/*
|
|
* Create a function for setting the source using a source object
|
|
* and source handlers.
|
|
* Should never be called unless a source handler was found.
|
|
* @param {Object} source A source object with src and type keys
|
|
* @return {Tech} self
|
|
*/
|
|
_Tech.prototype.setSource = function (source) {
|
|
var sh = _Tech.selectSourceHandler(source);
|
|
|
|
if (!sh) {
|
|
// Fall back to a native source hander when unsupported sources are
|
|
// deliberately set
|
|
if (_Tech.nativeSourceHandler) {
|
|
sh = _Tech.nativeSourceHandler;
|
|
} else {
|
|
_utilsLogJs2['default'].error('No source hander found for the current source.');
|
|
}
|
|
}
|
|
|
|
// Dispose any existing source handler
|
|
this.disposeSourceHandler();
|
|
this.off('dispose', this.disposeSourceHandler);
|
|
|
|
// if we have a source and get another one
|
|
// then we are loading something new
|
|
// than clear all of our current tracks
|
|
if (this.currentSource_) {
|
|
this.clearTracks(['audio', 'video']);
|
|
|
|
this.currentSource_ = null;
|
|
}
|
|
|
|
if (sh !== _Tech.nativeSourceHandler) {
|
|
|
|
this.currentSource_ = source;
|
|
|
|
// Catch if someone replaced the src without calling setSource.
|
|
// If they do, set currentSource_ to null and dispose our source handler.
|
|
this.off(this.el_, 'loadstart', _Tech.prototype.firstLoadStartListener_);
|
|
this.off(this.el_, 'loadstart', _Tech.prototype.successiveLoadStartListener_);
|
|
this.one(this.el_, 'loadstart', _Tech.prototype.firstLoadStartListener_);
|
|
}
|
|
|
|
this.sourceHandler_ = sh.handleSource(source, this, this.options_);
|
|
this.on('dispose', this.disposeSourceHandler);
|
|
|
|
return this;
|
|
};
|
|
|
|
// On the first loadstart after setSource
|
|
_Tech.prototype.firstLoadStartListener_ = function () {
|
|
this.one(this.el_, 'loadstart', _Tech.prototype.successiveLoadStartListener_);
|
|
};
|
|
|
|
// On successive loadstarts when setSource has not been called again
|
|
_Tech.prototype.successiveLoadStartListener_ = function () {
|
|
this.currentSource_ = null;
|
|
this.disposeSourceHandler();
|
|
this.one(this.el_, 'loadstart', _Tech.prototype.successiveLoadStartListener_);
|
|
};
|
|
|
|
/*
|
|
* Clean up any existing source handler
|
|
*/
|
|
_Tech.prototype.disposeSourceHandler = function () {
|
|
if (this.sourceHandler_ && this.sourceHandler_.dispose) {
|
|
this.off(this.el_, 'loadstart', _Tech.prototype.firstLoadStartListener_);
|
|
this.off(this.el_, 'loadstart', _Tech.prototype.successiveLoadStartListener_);
|
|
this.sourceHandler_.dispose();
|
|
}
|
|
};
|
|
};
|
|
|
|
_component2['default'].registerComponent('Tech', Tech);
|
|
// Old name for Tech
|
|
_component2['default'].registerComponent('MediaTechController', Tech);
|
|
Tech.registerTech('Tech', Tech);
|
|
exports['default'] = Tech;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component":67,"../media-error.js":108,"../tracks/audio-track":126,"../tracks/audio-track-list":125,"../tracks/html-track-element":128,"../tracks/html-track-element-list":127,"../tracks/text-track":134,"../tracks/text-track-list":132,"../tracks/video-track":139,"../tracks/video-track-list":138,"../utils/buffer.js":141,"../utils/fn.js":145,"../utils/log.js":148,"../utils/merge-options.js":149,"../utils/time-ranges.js":151,"global/document":1,"global/window":2}],125:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file audio-track-list.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackList = _dereq_('./track-list');
|
|
|
|
var _trackList2 = _interopRequireDefault(_trackList);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* anywhere we call this function we diverge from the spec
|
|
* as we only support one enabled audiotrack at a time
|
|
*
|
|
* @param {Array|AudioTrackList} list list to work on
|
|
* @param {AudioTrack} track the track to skip
|
|
*/
|
|
var disableOthers = function disableOthers(list, track) {
|
|
for (var i = 0; i < list.length; i++) {
|
|
if (track.id === list[i].id) {
|
|
continue;
|
|
}
|
|
// another audio track is enabled, disable it
|
|
list[i].enabled = false;
|
|
}
|
|
};
|
|
/**
|
|
* A list of possible audio tracks. All functionality is in the
|
|
* base class Tracklist and the spec for AudioTrackList is located at:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#audiotracklist
|
|
*
|
|
* interface AudioTrackList : EventTarget {
|
|
* readonly attribute unsigned long length;
|
|
* getter AudioTrack (unsigned long index);
|
|
* AudioTrack? getTrackById(DOMString id);
|
|
*
|
|
* attribute EventHandler onchange;
|
|
* attribute EventHandler onaddtrack;
|
|
* attribute EventHandler onremovetrack;
|
|
* };
|
|
*
|
|
* @param {AudioTrack[]} tracks a list of audio tracks to instantiate the list with
|
|
* @extends TrackList
|
|
* @class AudioTrackList
|
|
*/
|
|
|
|
var AudioTrackList = (function (_TrackList) {
|
|
_inherits(AudioTrackList, _TrackList);
|
|
|
|
function AudioTrackList() {
|
|
var tracks = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
_classCallCheck(this, AudioTrackList);
|
|
|
|
var list = undefined;
|
|
|
|
// make sure only 1 track is enabled
|
|
// sorted from last index to first index
|
|
for (var i = tracks.length - 1; i >= 0; i--) {
|
|
if (tracks[i].enabled) {
|
|
disableOthers(tracks, tracks[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// IE8 forces us to implement inheritance ourselves
|
|
// as it does not support Object.defineProperty properly
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
for (var prop in _trackList2['default'].prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = _trackList2['default'].prototype[prop];
|
|
}
|
|
}
|
|
for (var prop in AudioTrackList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = AudioTrackList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
list = _TrackList.call(this, tracks, list);
|
|
list.changing_ = false;
|
|
|
|
return list;
|
|
}
|
|
|
|
AudioTrackList.prototype.addTrack_ = function addTrack_(track) {
|
|
var _this = this;
|
|
|
|
if (track.enabled) {
|
|
disableOthers(this, track);
|
|
}
|
|
|
|
_TrackList.prototype.addTrack_.call(this, track);
|
|
// native tracks don't have this
|
|
if (!track.addEventListener) {
|
|
return;
|
|
}
|
|
|
|
track.addEventListener('enabledchange', function () {
|
|
// when we are disabling other tracks (since we don't support
|
|
// more than one track at a time) we will set changing_
|
|
// to true so that we don't trigger additional change events
|
|
if (_this.changing_) {
|
|
return;
|
|
}
|
|
_this.changing_ = true;
|
|
disableOthers(_this, track);
|
|
_this.changing_ = false;
|
|
_this.trigger('change');
|
|
});
|
|
};
|
|
|
|
AudioTrackList.prototype.addTrack = function addTrack(track) {
|
|
this.addTrack_(track);
|
|
};
|
|
|
|
AudioTrackList.prototype.removeTrack = function removeTrack(track) {
|
|
_TrackList.prototype.removeTrack_.call(this, track);
|
|
};
|
|
|
|
return AudioTrackList;
|
|
})(_trackList2['default']);
|
|
|
|
exports['default'] = AudioTrackList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"./track-list":136,"global/document":1}],126:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackEnums = _dereq_('./track-enums');
|
|
|
|
var _track = _dereq_('./track');
|
|
|
|
var _track2 = _interopRequireDefault(_track);
|
|
|
|
var _utilsMergeOptions = _dereq_('../utils/merge-options');
|
|
|
|
var _utilsMergeOptions2 = _interopRequireDefault(_utilsMergeOptions);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
/**
|
|
* A single audio text track as defined in:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#audiotrack
|
|
*
|
|
* interface AudioTrack {
|
|
* readonly attribute DOMString id;
|
|
* readonly attribute DOMString kind;
|
|
* readonly attribute DOMString label;
|
|
* readonly attribute DOMString language;
|
|
* attribute boolean enabled;
|
|
* };
|
|
*
|
|
* @param {Object=} options Object of option names and values
|
|
* @class AudioTrack
|
|
*/
|
|
|
|
var AudioTrack = (function (_Track) {
|
|
_inherits(AudioTrack, _Track);
|
|
|
|
function AudioTrack() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
_classCallCheck(this, AudioTrack);
|
|
|
|
var settings = _utilsMergeOptions2['default'](options, {
|
|
kind: _trackEnums.AudioTrackKind[options.kind] || ''
|
|
});
|
|
// on IE8 this will be a document element
|
|
// for every other browser this will be a normal object
|
|
var track = _Track.call(this, settings);
|
|
var enabled = false;
|
|
|
|
if (browser.IS_IE8) {
|
|
for (var prop in AudioTrack.prototype) {
|
|
if (prop !== 'constructor') {
|
|
track[prop] = AudioTrack.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(track, 'enabled', {
|
|
get: function get() {
|
|
return enabled;
|
|
},
|
|
set: function set(newEnabled) {
|
|
// an invalid or unchanged value
|
|
if (typeof newEnabled !== 'boolean' || newEnabled === enabled) {
|
|
return;
|
|
}
|
|
enabled = newEnabled;
|
|
this.trigger('enabledchange');
|
|
}
|
|
});
|
|
|
|
// if the user sets this track to selected then
|
|
// set selected to that true value otherwise
|
|
// we keep it false
|
|
if (settings.enabled) {
|
|
track.enabled = settings.enabled;
|
|
}
|
|
track.loaded_ = true;
|
|
|
|
return track;
|
|
}
|
|
|
|
return AudioTrack;
|
|
})(_track2['default']);
|
|
|
|
exports['default'] = AudioTrack;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"../utils/merge-options":149,"./track":137,"./track-enums":135}],127:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file html-track-element-list.js
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var HtmlTrackElementList = (function () {
|
|
function HtmlTrackElementList() {
|
|
var trackElements = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
_classCallCheck(this, HtmlTrackElementList);
|
|
|
|
var list = this;
|
|
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
|
|
for (var prop in HtmlTrackElementList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = HtmlTrackElementList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
list.trackElements_ = [];
|
|
|
|
Object.defineProperty(list, 'length', {
|
|
get: function get() {
|
|
return this.trackElements_.length;
|
|
}
|
|
});
|
|
|
|
for (var i = 0, _length = trackElements.length; i < _length; i++) {
|
|
list.addTrackElement_(trackElements[i]);
|
|
}
|
|
|
|
if (browser.IS_IE8) {
|
|
return list;
|
|
}
|
|
}
|
|
|
|
HtmlTrackElementList.prototype.addTrackElement_ = function addTrackElement_(trackElement) {
|
|
this.trackElements_.push(trackElement);
|
|
};
|
|
|
|
HtmlTrackElementList.prototype.getTrackElementByTrack_ = function getTrackElementByTrack_(track) {
|
|
var trackElement_ = undefined;
|
|
|
|
for (var i = 0, _length2 = this.trackElements_.length; i < _length2; i++) {
|
|
if (track === this.trackElements_[i].track) {
|
|
trackElement_ = this.trackElements_[i];
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return trackElement_;
|
|
};
|
|
|
|
HtmlTrackElementList.prototype.removeTrackElement_ = function removeTrackElement_(trackElement) {
|
|
for (var i = 0, _length3 = this.trackElements_.length; i < _length3; i++) {
|
|
if (trackElement === this.trackElements_[i]) {
|
|
this.trackElements_.splice(i, 1);
|
|
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
return HtmlTrackElementList;
|
|
})();
|
|
|
|
exports['default'] = HtmlTrackElementList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"global/document":1}],128:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file html-track-element.js
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
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 _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _eventTarget = _dereq_('../event-target');
|
|
|
|
var _eventTarget2 = _interopRequireDefault(_eventTarget);
|
|
|
|
var _tracksTextTrack = _dereq_('../tracks/text-track');
|
|
|
|
var _tracksTextTrack2 = _interopRequireDefault(_tracksTextTrack);
|
|
|
|
var NONE = 0;
|
|
var LOADING = 1;
|
|
var LOADED = 2;
|
|
var ERROR = 3;
|
|
|
|
/**
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#htmltrackelement
|
|
*
|
|
* interface HTMLTrackElement : HTMLElement {
|
|
* attribute DOMString kind;
|
|
* attribute DOMString src;
|
|
* attribute DOMString srclang;
|
|
* attribute DOMString label;
|
|
* attribute boolean default;
|
|
*
|
|
* const unsigned short NONE = 0;
|
|
* const unsigned short LOADING = 1;
|
|
* const unsigned short LOADED = 2;
|
|
* const unsigned short ERROR = 3;
|
|
* readonly attribute unsigned short readyState;
|
|
*
|
|
* readonly attribute TextTrack track;
|
|
* };
|
|
*
|
|
* @param {Object} options TextTrack configuration
|
|
* @class HTMLTrackElement
|
|
*/
|
|
|
|
var HTMLTrackElement = (function (_EventTarget) {
|
|
_inherits(HTMLTrackElement, _EventTarget);
|
|
|
|
function HTMLTrackElement() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
_classCallCheck(this, HTMLTrackElement);
|
|
|
|
_EventTarget.call(this);
|
|
|
|
var readyState = undefined,
|
|
trackElement = this;
|
|
|
|
if (browser.IS_IE8) {
|
|
trackElement = _globalDocument2['default'].createElement('custom');
|
|
|
|
for (var prop in HTMLTrackElement.prototype) {
|
|
if (prop !== 'constructor') {
|
|
trackElement[prop] = HTMLTrackElement.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
var track = new _tracksTextTrack2['default'](options);
|
|
|
|
trackElement.kind = track.kind;
|
|
trackElement.src = track.src;
|
|
trackElement.srclang = track.language;
|
|
trackElement.label = track.label;
|
|
trackElement['default'] = track['default'];
|
|
|
|
Object.defineProperty(trackElement, 'readyState', {
|
|
get: function get() {
|
|
return readyState;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(trackElement, 'track', {
|
|
get: function get() {
|
|
return track;
|
|
}
|
|
});
|
|
|
|
readyState = NONE;
|
|
|
|
track.addEventListener('loadeddata', function () {
|
|
readyState = LOADED;
|
|
|
|
trackElement.trigger({
|
|
type: 'load',
|
|
target: trackElement
|
|
});
|
|
});
|
|
|
|
if (browser.IS_IE8) {
|
|
return trackElement;
|
|
}
|
|
}
|
|
|
|
return HTMLTrackElement;
|
|
})(_eventTarget2['default']);
|
|
|
|
HTMLTrackElement.prototype.allowedEvents_ = {
|
|
load: 'load'
|
|
};
|
|
|
|
HTMLTrackElement.NONE = NONE;
|
|
HTMLTrackElement.LOADING = LOADING;
|
|
HTMLTrackElement.LOADED = LOADED;
|
|
HTMLTrackElement.ERROR = ERROR;
|
|
|
|
exports['default'] = HTMLTrackElement;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../event-target":104,"../tracks/text-track":134,"../utils/browser.js":140,"global/document":1}],129:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-cue-list.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* A List of text track cues as defined in:
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#texttrackcuelist
|
|
*
|
|
* interface TextTrackCueList {
|
|
* readonly attribute unsigned long length;
|
|
* getter TextTrackCue (unsigned long index);
|
|
* TextTrackCue? getCueById(DOMString id);
|
|
* };
|
|
*
|
|
* @param {Array} cues A list of cues to be initialized with
|
|
* @class TextTrackCueList
|
|
*/
|
|
|
|
var TextTrackCueList = (function () {
|
|
function TextTrackCueList(cues) {
|
|
_classCallCheck(this, TextTrackCueList);
|
|
|
|
var list = this;
|
|
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
|
|
for (var prop in TextTrackCueList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = TextTrackCueList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
TextTrackCueList.prototype.setCues_.call(list, cues);
|
|
|
|
Object.defineProperty(list, 'length', {
|
|
get: function get() {
|
|
return this.length_;
|
|
}
|
|
});
|
|
|
|
if (browser.IS_IE8) {
|
|
return list;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A setter for cues in this list
|
|
*
|
|
* @param {Array} cues an array of cues
|
|
* @method setCues_
|
|
* @private
|
|
*/
|
|
|
|
TextTrackCueList.prototype.setCues_ = function setCues_(cues) {
|
|
var oldLength = this.length || 0;
|
|
var i = 0;
|
|
var l = cues.length;
|
|
|
|
this.cues_ = cues;
|
|
this.length_ = cues.length;
|
|
|
|
var defineProp = function defineProp(index) {
|
|
if (!('' + index in this)) {
|
|
Object.defineProperty(this, '' + index, {
|
|
get: function get() {
|
|
return this.cues_[index];
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
if (oldLength < l) {
|
|
i = oldLength;
|
|
|
|
for (; i < l; i++) {
|
|
defineProp.call(this, i);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get a cue that is currently in the Cue list by id
|
|
*
|
|
* @param {String} id
|
|
* @method getCueById
|
|
* @return {Object} a single cue
|
|
*/
|
|
|
|
TextTrackCueList.prototype.getCueById = function getCueById(id) {
|
|
var result = null;
|
|
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
var cue = this[i];
|
|
|
|
if (cue.id === id) {
|
|
result = cue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
return TextTrackCueList;
|
|
})();
|
|
|
|
exports['default'] = TextTrackCueList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"global/document":1}],130:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-display.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _menuMenuJs = _dereq_('../menu/menu.js');
|
|
|
|
var _menuMenuJs2 = _interopRequireDefault(_menuMenuJs);
|
|
|
|
var _menuMenuItemJs = _dereq_('../menu/menu-item.js');
|
|
|
|
var _menuMenuItemJs2 = _interopRequireDefault(_menuMenuItemJs);
|
|
|
|
var _menuMenuButtonJs = _dereq_('../menu/menu-button.js');
|
|
|
|
var _menuMenuButtonJs2 = _interopRequireDefault(_menuMenuButtonJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var darkGray = '#222';
|
|
var lightGray = '#ccc';
|
|
var fontMap = {
|
|
monospace: 'monospace',
|
|
sansSerif: 'sans-serif',
|
|
serif: 'serif',
|
|
monospaceSansSerif: '"Andale Mono", "Lucida Console", monospace',
|
|
monospaceSerif: '"Courier New", monospace',
|
|
proportionalSansSerif: 'sans-serif',
|
|
proportionalSerif: 'serif',
|
|
casual: '"Comic Sans MS", Impact, fantasy',
|
|
script: '"Monotype Corsiva", cursive',
|
|
smallcaps: '"Andale Mono", "Lucida Console", monospace, sans-serif'
|
|
};
|
|
|
|
/**
|
|
* The component for displaying text track cues
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @param {Function=} ready Ready callback function
|
|
* @extends Component
|
|
* @class TextTrackDisplay
|
|
*/
|
|
|
|
var TextTrackDisplay = (function (_Component) {
|
|
_inherits(TextTrackDisplay, _Component);
|
|
|
|
function TextTrackDisplay(player, options, ready) {
|
|
_classCallCheck(this, TextTrackDisplay);
|
|
|
|
_Component.call(this, player, options, ready);
|
|
|
|
player.on('loadstart', Fn.bind(this, this.toggleDisplay));
|
|
player.on('texttrackchange', Fn.bind(this, this.updateDisplay));
|
|
|
|
// This used to be called during player init, but was causing an error
|
|
// if a track should show by default and the display hadn't loaded yet.
|
|
// Should probably be moved to an external track loader when we support
|
|
// tracks that don't need a display.
|
|
player.ready(Fn.bind(this, function () {
|
|
if (player.tech_ && player.tech_['featuresNativeTextTracks']) {
|
|
this.hide();
|
|
return;
|
|
}
|
|
|
|
player.on('fullscreenchange', Fn.bind(this, this.updateDisplay));
|
|
|
|
var tracks = this.options_.playerOptions['tracks'] || [];
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
var track = tracks[i];
|
|
this.player_.addRemoteTextTrack(track);
|
|
}
|
|
|
|
var modes = { 'captions': 1, 'subtitles': 1 };
|
|
var trackList = this.player_.textTracks();
|
|
var firstDesc = undefined;
|
|
var firstCaptions = undefined;
|
|
|
|
if (trackList) {
|
|
for (var i = 0; i < trackList.length; i++) {
|
|
var track = trackList[i];
|
|
if (track['default']) {
|
|
if (track.kind === 'descriptions' && !firstDesc) {
|
|
firstDesc = track;
|
|
} else if (track.kind in modes && !firstCaptions) {
|
|
firstCaptions = track;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We want to show the first default track but captions and subtitles
|
|
// take precedence over descriptions.
|
|
// So, display the first default captions or subtitles track
|
|
// and otherwise the first default descriptions track.
|
|
if (firstCaptions) {
|
|
firstCaptions.mode = 'showing';
|
|
} else if (firstDesc) {
|
|
firstDesc.mode = 'showing';
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Add cue HTML to display
|
|
*
|
|
* @param {Number} color Hex number for color, like #f0e
|
|
* @param {Number} opacity Value for opacity,0.0 - 1.0
|
|
* @return {RGBAColor} In the form 'rgba(255, 0, 0, 0.3)'
|
|
* @method constructColor
|
|
*/
|
|
|
|
/**
|
|
* Toggle display texttracks
|
|
*
|
|
* @method toggleDisplay
|
|
*/
|
|
|
|
TextTrackDisplay.prototype.toggleDisplay = function toggleDisplay() {
|
|
if (this.player_.tech_ && this.player_.tech_['featuresNativeTextTracks']) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
TextTrackDisplay.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-text-track-display'
|
|
}, {
|
|
'aria-live': 'assertive',
|
|
'aria-atomic': 'true'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Clear display texttracks
|
|
*
|
|
* @method clearDisplay
|
|
*/
|
|
|
|
TextTrackDisplay.prototype.clearDisplay = function clearDisplay() {
|
|
if (typeof _globalWindow2['default']['WebVTT'] === 'function') {
|
|
_globalWindow2['default']['WebVTT']['processCues'](_globalWindow2['default'], [], this.el_);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update display texttracks
|
|
*
|
|
* @method updateDisplay
|
|
*/
|
|
|
|
TextTrackDisplay.prototype.updateDisplay = function updateDisplay() {
|
|
var tracks = this.player_.textTracks();
|
|
|
|
this.clearDisplay();
|
|
|
|
if (!tracks) {
|
|
return;
|
|
}
|
|
|
|
// Track display prioritization model: if multiple tracks are 'showing',
|
|
// display the first 'subtitles' or 'captions' track which is 'showing',
|
|
// otherwise display the first 'descriptions' track which is 'showing'
|
|
|
|
var descriptionsTrack = null;
|
|
var captionsSubtitlesTrack = null;
|
|
|
|
var i = tracks.length;
|
|
while (i--) {
|
|
var track = tracks[i];
|
|
if (track['mode'] === 'showing') {
|
|
if (track['kind'] === 'descriptions') {
|
|
descriptionsTrack = track;
|
|
} else {
|
|
captionsSubtitlesTrack = track;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (captionsSubtitlesTrack) {
|
|
this.updateForTrack(captionsSubtitlesTrack);
|
|
} else if (descriptionsTrack) {
|
|
this.updateForTrack(descriptionsTrack);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Add texttrack to texttrack list
|
|
*
|
|
* @param {TextTrackObject} track Texttrack object to be added to list
|
|
* @method updateForTrack
|
|
*/
|
|
|
|
TextTrackDisplay.prototype.updateForTrack = function updateForTrack(track) {
|
|
if (typeof _globalWindow2['default']['WebVTT'] !== 'function' || !track['activeCues']) {
|
|
return;
|
|
}
|
|
|
|
var overrides = this.player_['textTrackSettings'].getValues();
|
|
|
|
var cues = [];
|
|
for (var _i = 0; _i < track['activeCues'].length; _i++) {
|
|
cues.push(track['activeCues'][_i]);
|
|
}
|
|
|
|
_globalWindow2['default']['WebVTT']['processCues'](_globalWindow2['default'], cues, this.el_);
|
|
|
|
var i = cues.length;
|
|
while (i--) {
|
|
var cue = cues[i];
|
|
if (!cue) {
|
|
continue;
|
|
}
|
|
|
|
var cueDiv = cue.displayState;
|
|
if (overrides.color) {
|
|
cueDiv.firstChild.style.color = overrides.color;
|
|
}
|
|
if (overrides.textOpacity) {
|
|
tryUpdateStyle(cueDiv.firstChild, 'color', constructColor(overrides.color || '#fff', overrides.textOpacity));
|
|
}
|
|
if (overrides.backgroundColor) {
|
|
cueDiv.firstChild.style.backgroundColor = overrides.backgroundColor;
|
|
}
|
|
if (overrides.backgroundOpacity) {
|
|
tryUpdateStyle(cueDiv.firstChild, 'backgroundColor', constructColor(overrides.backgroundColor || '#000', overrides.backgroundOpacity));
|
|
}
|
|
if (overrides.windowColor) {
|
|
if (overrides.windowOpacity) {
|
|
tryUpdateStyle(cueDiv, 'backgroundColor', constructColor(overrides.windowColor, overrides.windowOpacity));
|
|
} else {
|
|
cueDiv.style.backgroundColor = overrides.windowColor;
|
|
}
|
|
}
|
|
if (overrides.edgeStyle) {
|
|
if (overrides.edgeStyle === 'dropshadow') {
|
|
cueDiv.firstChild.style.textShadow = '2px 2px 3px ' + darkGray + ', 2px 2px 4px ' + darkGray + ', 2px 2px 5px ' + darkGray;
|
|
} else if (overrides.edgeStyle === 'raised') {
|
|
cueDiv.firstChild.style.textShadow = '1px 1px ' + darkGray + ', 2px 2px ' + darkGray + ', 3px 3px ' + darkGray;
|
|
} else if (overrides.edgeStyle === 'depressed') {
|
|
cueDiv.firstChild.style.textShadow = '1px 1px ' + lightGray + ', 0 1px ' + lightGray + ', -1px -1px ' + darkGray + ', 0 -1px ' + darkGray;
|
|
} else if (overrides.edgeStyle === 'uniform') {
|
|
cueDiv.firstChild.style.textShadow = '0 0 4px ' + darkGray + ', 0 0 4px ' + darkGray + ', 0 0 4px ' + darkGray + ', 0 0 4px ' + darkGray;
|
|
}
|
|
}
|
|
if (overrides.fontPercent && overrides.fontPercent !== 1) {
|
|
var fontSize = _globalWindow2['default'].parseFloat(cueDiv.style.fontSize);
|
|
cueDiv.style.fontSize = fontSize * overrides.fontPercent + 'px';
|
|
cueDiv.style.height = 'auto';
|
|
cueDiv.style.top = 'auto';
|
|
cueDiv.style.bottom = '2px';
|
|
}
|
|
if (overrides.fontFamily && overrides.fontFamily !== 'default') {
|
|
if (overrides.fontFamily === 'small-caps') {
|
|
cueDiv.firstChild.style.fontVariant = 'small-caps';
|
|
} else {
|
|
cueDiv.firstChild.style.fontFamily = fontMap[overrides.fontFamily];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
return TextTrackDisplay;
|
|
})(_component2['default']);
|
|
|
|
function constructColor(color, opacity) {
|
|
return 'rgba(' +
|
|
// color looks like "#f0e"
|
|
parseInt(color[1] + color[1], 16) + ',' + parseInt(color[2] + color[2], 16) + ',' + parseInt(color[3] + color[3], 16) + ',' + opacity + ')';
|
|
}
|
|
|
|
/**
|
|
* Try to update style
|
|
* Some style changes will throw an error, particularly in IE8. Those should be noops.
|
|
*
|
|
* @param {Element} el The element to be styles
|
|
* @param {CSSProperty} style The CSS property to be styled
|
|
* @param {CSSStyle} rule The actual style to be applied to the property
|
|
* @method tryUpdateStyle
|
|
*/
|
|
function tryUpdateStyle(el, style, rule) {
|
|
//
|
|
try {
|
|
el.style[style] = rule;
|
|
} catch (e) {}
|
|
}
|
|
|
|
_component2['default'].registerComponent('TextTrackDisplay', TextTrackDisplay);
|
|
exports['default'] = TextTrackDisplay;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component":67,"../menu/menu-button.js":109,"../menu/menu-item.js":110,"../menu/menu.js":111,"../utils/fn.js":145,"global/document":1,"global/window":2}],131:[function(_dereq_,module,exports){
|
|
/**
|
|
* Utilities for capturing text track state and re-creating tracks
|
|
* based on a capture.
|
|
*
|
|
* @file text-track-list-converter.js
|
|
*/
|
|
|
|
/**
|
|
* Examine a single text track and return a JSON-compatible javascript
|
|
* object that represents the text track's state.
|
|
* @param track {TextTrackObject} the text track to query
|
|
* @return {Object} a serializable javascript representation of the
|
|
* @private
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
var trackToJson_ = function trackToJson_(track) {
|
|
var ret = ['kind', 'label', 'language', 'id', 'inBandMetadataTrackDispatchType', 'mode', 'src'].reduce(function (acc, prop, i) {
|
|
if (track[prop]) {
|
|
acc[prop] = track[prop];
|
|
}
|
|
|
|
return acc;
|
|
}, {
|
|
cues: track.cues && Array.prototype.map.call(track.cues, function (cue) {
|
|
return {
|
|
startTime: cue.startTime,
|
|
endTime: cue.endTime,
|
|
text: cue.text,
|
|
id: cue.id
|
|
};
|
|
})
|
|
});
|
|
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* Examine a tech and return a JSON-compatible javascript array that
|
|
* represents the state of all text tracks currently configured. The
|
|
* return array is compatible with `jsonToTextTracks`.
|
|
* @param tech {tech} the tech object to query
|
|
* @return {Array} a serializable javascript representation of the
|
|
* @function textTracksToJson
|
|
*/
|
|
var textTracksToJson = function textTracksToJson(tech) {
|
|
|
|
var trackEls = tech.$$('track');
|
|
|
|
var trackObjs = Array.prototype.map.call(trackEls, function (t) {
|
|
return t.track;
|
|
});
|
|
var tracks = Array.prototype.map.call(trackEls, function (trackEl) {
|
|
var json = trackToJson_(trackEl.track);
|
|
if (trackEl.src) {
|
|
json.src = trackEl.src;
|
|
}
|
|
return json;
|
|
});
|
|
|
|
return tracks.concat(Array.prototype.filter.call(tech.textTracks(), function (track) {
|
|
return trackObjs.indexOf(track) === -1;
|
|
}).map(trackToJson_));
|
|
};
|
|
|
|
/**
|
|
* Creates a set of remote text tracks on a tech based on an array of
|
|
* javascript text track representations.
|
|
* @param json {Array} an array of text track representation objects,
|
|
* like those that would be produced by `textTracksToJson`
|
|
* @param tech {tech} the tech to create text tracks on
|
|
* @function jsonToTextTracks
|
|
*/
|
|
var jsonToTextTracks = function jsonToTextTracks(json, tech) {
|
|
json.forEach(function (track) {
|
|
var addedTrack = tech.addRemoteTextTrack(track).track;
|
|
if (!track.src && track.cues) {
|
|
track.cues.forEach(function (cue) {
|
|
return addedTrack.addCue(cue);
|
|
});
|
|
}
|
|
});
|
|
|
|
return tech.textTracks();
|
|
};
|
|
|
|
exports['default'] = { textTracksToJson: textTracksToJson, jsonToTextTracks: jsonToTextTracks, trackToJson_: trackToJson_ };
|
|
module.exports = exports['default'];
|
|
|
|
},{}],132:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-list.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackList = _dereq_('./track-list');
|
|
|
|
var _trackList2 = _interopRequireDefault(_trackList);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* A list of possible text tracks. All functionality is in the
|
|
* base class TrackList. The spec for TextTrackList is located at:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#texttracklist
|
|
*
|
|
* interface TextTrackList : EventTarget {
|
|
* readonly attribute unsigned long length;
|
|
* getter TextTrack (unsigned long index);
|
|
* TextTrack? getTrackById(DOMString id);
|
|
*
|
|
* attribute EventHandler onchange;
|
|
* attribute EventHandler onaddtrack;
|
|
* attribute EventHandler onremovetrack;
|
|
* };
|
|
*
|
|
* @param {TextTrack[]} tracks A list of tracks to initialize the list with
|
|
* @extends TrackList
|
|
* @class TextTrackList
|
|
*/
|
|
|
|
var TextTrackList = (function (_TrackList) {
|
|
_inherits(TextTrackList, _TrackList);
|
|
|
|
function TextTrackList() {
|
|
var tracks = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
_classCallCheck(this, TextTrackList);
|
|
|
|
var list = undefined;
|
|
|
|
// IE8 forces us to implement inheritance ourselves
|
|
// as it does not support Object.defineProperty properly
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
for (var prop in _trackList2['default'].prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = _trackList2['default'].prototype[prop];
|
|
}
|
|
}
|
|
for (var prop in TextTrackList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = TextTrackList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
list = _TrackList.call(this, tracks, list);
|
|
return list;
|
|
}
|
|
|
|
TextTrackList.prototype.addTrack_ = function addTrack_(track) {
|
|
_TrackList.prototype.addTrack_.call(this, track);
|
|
track.addEventListener('modechange', Fn.bind(this, function () {
|
|
this.trigger('change');
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Remove TextTrack from TextTrackList
|
|
* NOTE: Be mindful of what is passed in as it may be a HTMLTrackElement
|
|
*
|
|
* @param {TextTrack} rtrack
|
|
* @method removeTrack_
|
|
* @private
|
|
*/
|
|
|
|
TextTrackList.prototype.removeTrack_ = function removeTrack_(rtrack) {
|
|
var track = undefined;
|
|
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
if (this[i] === rtrack) {
|
|
track = this[i];
|
|
if (track.off) {
|
|
track.off();
|
|
}
|
|
|
|
this.tracks_.splice(i, 1);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!track) {
|
|
return;
|
|
}
|
|
|
|
this.trigger({
|
|
track: track,
|
|
type: 'removetrack'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get a TextTrack from TextTrackList by a tracks id
|
|
*
|
|
* @param {String} id - the id of the track to get
|
|
* @method getTrackById
|
|
* @return {TextTrack}
|
|
* @private
|
|
*/
|
|
|
|
TextTrackList.prototype.getTrackById = function getTrackById(id) {
|
|
var result = null;
|
|
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
var track = this[i];
|
|
|
|
if (track.id === id) {
|
|
result = track;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
return TextTrackList;
|
|
})(_trackList2['default']);
|
|
|
|
exports['default'] = TextTrackList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"../utils/fn.js":145,"./track-list":136,"global/document":1}],133:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track-settings.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _component = _dereq_('../component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _utilsEventsJs = _dereq_('../utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsLogJs = _dereq_('../utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _safeJsonParseTuple = _dereq_('safe-json-parse/tuple');
|
|
|
|
var _safeJsonParseTuple2 = _interopRequireDefault(_safeJsonParseTuple);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
/**
|
|
* Manipulate settings of texttracks
|
|
*
|
|
* @param {Object} player Main Player
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends Component
|
|
* @class TextTrackSettings
|
|
*/
|
|
|
|
var TextTrackSettings = (function (_Component) {
|
|
_inherits(TextTrackSettings, _Component);
|
|
|
|
function TextTrackSettings(player, options) {
|
|
_classCallCheck(this, TextTrackSettings);
|
|
|
|
_Component.call(this, player, options);
|
|
this.hide();
|
|
|
|
// Grab `persistTextTrackSettings` from the player options if not passed in child options
|
|
if (options.persistTextTrackSettings === undefined) {
|
|
this.options_.persistTextTrackSettings = this.options_.playerOptions.persistTextTrackSettings;
|
|
}
|
|
|
|
Events.on(this.$('.vjs-done-button'), 'click', Fn.bind(this, function () {
|
|
this.saveSettings();
|
|
this.hide();
|
|
}));
|
|
|
|
Events.on(this.$('.vjs-default-button'), 'click', Fn.bind(this, function () {
|
|
this.$('.vjs-fg-color > select').selectedIndex = 0;
|
|
this.$('.vjs-bg-color > select').selectedIndex = 0;
|
|
this.$('.window-color > select').selectedIndex = 0;
|
|
this.$('.vjs-text-opacity > select').selectedIndex = 0;
|
|
this.$('.vjs-bg-opacity > select').selectedIndex = 0;
|
|
this.$('.vjs-window-opacity > select').selectedIndex = 0;
|
|
this.$('.vjs-edge-style select').selectedIndex = 0;
|
|
this.$('.vjs-font-family select').selectedIndex = 0;
|
|
this.$('.vjs-font-percent select').selectedIndex = 2;
|
|
this.updateDisplay();
|
|
}));
|
|
|
|
Events.on(this.$('.vjs-fg-color > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-bg-color > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.window-color > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-text-opacity > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-bg-opacity > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-window-opacity > select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-font-percent select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-edge-style select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
Events.on(this.$('.vjs-font-family select'), 'change', Fn.bind(this, this.updateDisplay));
|
|
|
|
if (this.options_.persistTextTrackSettings) {
|
|
this.restoreSettings();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the component's DOM element
|
|
*
|
|
* @return {Element}
|
|
* @method createEl
|
|
*/
|
|
|
|
TextTrackSettings.prototype.createEl = function createEl() {
|
|
return _Component.prototype.createEl.call(this, 'div', {
|
|
className: 'vjs-caption-settings vjs-modal-overlay',
|
|
innerHTML: captionOptionsMenuTemplate()
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get texttrack settings
|
|
* Settings are
|
|
* .vjs-edge-style
|
|
* .vjs-font-family
|
|
* .vjs-fg-color
|
|
* .vjs-text-opacity
|
|
* .vjs-bg-color
|
|
* .vjs-bg-opacity
|
|
* .window-color
|
|
* .vjs-window-opacity
|
|
*
|
|
* @return {Object}
|
|
* @method getValues
|
|
*/
|
|
|
|
TextTrackSettings.prototype.getValues = function getValues() {
|
|
var textEdge = getSelectedOptionValue(this.$('.vjs-edge-style select'));
|
|
var fontFamily = getSelectedOptionValue(this.$('.vjs-font-family select'));
|
|
var fgColor = getSelectedOptionValue(this.$('.vjs-fg-color > select'));
|
|
var textOpacity = getSelectedOptionValue(this.$('.vjs-text-opacity > select'));
|
|
var bgColor = getSelectedOptionValue(this.$('.vjs-bg-color > select'));
|
|
var bgOpacity = getSelectedOptionValue(this.$('.vjs-bg-opacity > select'));
|
|
var windowColor = getSelectedOptionValue(this.$('.window-color > select'));
|
|
var windowOpacity = getSelectedOptionValue(this.$('.vjs-window-opacity > select'));
|
|
var fontPercent = _globalWindow2['default']['parseFloat'](getSelectedOptionValue(this.$('.vjs-font-percent > select')));
|
|
|
|
var result = {
|
|
'backgroundOpacity': bgOpacity,
|
|
'textOpacity': textOpacity,
|
|
'windowOpacity': windowOpacity,
|
|
'edgeStyle': textEdge,
|
|
'fontFamily': fontFamily,
|
|
'color': fgColor,
|
|
'backgroundColor': bgColor,
|
|
'windowColor': windowColor,
|
|
'fontPercent': fontPercent
|
|
};
|
|
for (var _name in result) {
|
|
if (result[_name] === '' || result[_name] === 'none' || _name === 'fontPercent' && result[_name] === 1.00) {
|
|
delete result[_name];
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Set texttrack settings
|
|
* Settings are
|
|
* .vjs-edge-style
|
|
* .vjs-font-family
|
|
* .vjs-fg-color
|
|
* .vjs-text-opacity
|
|
* .vjs-bg-color
|
|
* .vjs-bg-opacity
|
|
* .window-color
|
|
* .vjs-window-opacity
|
|
*
|
|
* @param {Object} values Object with texttrack setting values
|
|
* @method setValues
|
|
*/
|
|
|
|
TextTrackSettings.prototype.setValues = function setValues(values) {
|
|
setSelectedOption(this.$('.vjs-edge-style select'), values.edgeStyle);
|
|
setSelectedOption(this.$('.vjs-font-family select'), values.fontFamily);
|
|
setSelectedOption(this.$('.vjs-fg-color > select'), values.color);
|
|
setSelectedOption(this.$('.vjs-text-opacity > select'), values.textOpacity);
|
|
setSelectedOption(this.$('.vjs-bg-color > select'), values.backgroundColor);
|
|
setSelectedOption(this.$('.vjs-bg-opacity > select'), values.backgroundOpacity);
|
|
setSelectedOption(this.$('.window-color > select'), values.windowColor);
|
|
setSelectedOption(this.$('.vjs-window-opacity > select'), values.windowOpacity);
|
|
|
|
var fontPercent = values.fontPercent;
|
|
|
|
if (fontPercent) {
|
|
fontPercent = fontPercent.toFixed(2);
|
|
}
|
|
|
|
setSelectedOption(this.$('.vjs-font-percent > select'), fontPercent);
|
|
};
|
|
|
|
/**
|
|
* Restore texttrack settings
|
|
*
|
|
* @method restoreSettings
|
|
*/
|
|
|
|
TextTrackSettings.prototype.restoreSettings = function restoreSettings() {
|
|
var err = undefined,
|
|
values = undefined;
|
|
|
|
try {
|
|
var _safeParseTuple = _safeJsonParseTuple2['default'](_globalWindow2['default'].localStorage.getItem('vjs-text-track-settings'));
|
|
|
|
err = _safeParseTuple[0];
|
|
values = _safeParseTuple[1];
|
|
|
|
if (err) {
|
|
_utilsLogJs2['default'].error(err);
|
|
}
|
|
} catch (e) {
|
|
_utilsLogJs2['default'].warn(e);
|
|
}
|
|
|
|
if (values) {
|
|
this.setValues(values);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Save texttrack settings to local storage
|
|
*
|
|
* @method saveSettings
|
|
*/
|
|
|
|
TextTrackSettings.prototype.saveSettings = function saveSettings() {
|
|
if (!this.options_.persistTextTrackSettings) {
|
|
return;
|
|
}
|
|
|
|
var values = this.getValues();
|
|
try {
|
|
if (Object.getOwnPropertyNames(values).length > 0) {
|
|
_globalWindow2['default'].localStorage.setItem('vjs-text-track-settings', JSON.stringify(values));
|
|
} else {
|
|
_globalWindow2['default'].localStorage.removeItem('vjs-text-track-settings');
|
|
}
|
|
} catch (e) {
|
|
_utilsLogJs2['default'].warn(e);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Update display of texttrack settings
|
|
*
|
|
* @method updateDisplay
|
|
*/
|
|
|
|
TextTrackSettings.prototype.updateDisplay = function updateDisplay() {
|
|
var ttDisplay = this.player_.getChild('textTrackDisplay');
|
|
if (ttDisplay) {
|
|
ttDisplay.updateDisplay();
|
|
}
|
|
};
|
|
|
|
return TextTrackSettings;
|
|
})(_component2['default']);
|
|
|
|
_component2['default'].registerComponent('TextTrackSettings', TextTrackSettings);
|
|
|
|
function getSelectedOptionValue(target) {
|
|
var selectedOption = undefined;
|
|
// not all browsers support selectedOptions, so, fallback to options
|
|
if (target.selectedOptions) {
|
|
selectedOption = target.selectedOptions[0];
|
|
} else if (target.options) {
|
|
selectedOption = target.options[target.options.selectedIndex];
|
|
}
|
|
|
|
return selectedOption.value;
|
|
}
|
|
|
|
function setSelectedOption(target, value) {
|
|
if (!value) {
|
|
return;
|
|
}
|
|
|
|
var i = undefined;
|
|
for (i = 0; i < target.options.length; i++) {
|
|
var option = target.options[i];
|
|
if (option.value === value) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
target.selectedIndex = i;
|
|
}
|
|
|
|
function captionOptionsMenuTemplate() {
|
|
var template = '<div class="vjs-tracksettings">\n <div class="vjs-tracksettings-colors">\n <div class="vjs-fg-color vjs-tracksetting">\n <label class="vjs-label">Foreground</label>\n <select>\n <option value="">---</option>\n <option value="#FFF">White</option>\n <option value="#000">Black</option>\n <option value="#F00">Red</option>\n <option value="#0F0">Green</option>\n <option value="#00F">Blue</option>\n <option value="#FF0">Yellow</option>\n <option value="#F0F">Magenta</option>\n <option value="#0FF">Cyan</option>\n </select>\n <span class="vjs-text-opacity vjs-opacity">\n <select>\n <option value="">---</option>\n <option value="1">Opaque</option>\n <option value="0.5">Semi-Opaque</option>\n </select>\n </span>\n </div> <!-- vjs-fg-color -->\n <div class="vjs-bg-color vjs-tracksetting">\n <label class="vjs-label">Background</label>\n <select>\n <option value="">---</option>\n <option value="#FFF">White</option>\n <option value="#000">Black</option>\n <option value="#F00">Red</option>\n <option value="#0F0">Green</option>\n <option value="#00F">Blue</option>\n <option value="#FF0">Yellow</option>\n <option value="#F0F">Magenta</option>\n <option value="#0FF">Cyan</option>\n </select>\n <span class="vjs-bg-opacity vjs-opacity">\n <select>\n <option value="">---</option>\n <option value="1">Opaque</option>\n <option value="0.5">Semi-Transparent</option>\n <option value="0">Transparent</option>\n </select>\n </span>\n </div> <!-- vjs-bg-color -->\n <div class="window-color vjs-tracksetting">\n <label class="vjs-label">Window</label>\n <select>\n <option value="">---</option>\n <option value="#FFF">White</option>\n <option value="#000">Black</option>\n <option value="#F00">Red</option>\n <option value="#0F0">Green</option>\n <option value="#00F">Blue</option>\n <option value="#FF0">Yellow</option>\n <option value="#F0F">Magenta</option>\n <option value="#0FF">Cyan</option>\n </select>\n <span class="vjs-window-opacity vjs-opacity">\n <select>\n <option value="">---</option>\n <option value="1">Opaque</option>\n <option value="0.5">Semi-Transparent</option>\n <option value="0">Transparent</option>\n </select>\n </span>\n </div> <!-- vjs-window-color -->\n </div> <!-- vjs-tracksettings -->\n <div class="vjs-tracksettings-font">\n <div class="vjs-font-percent vjs-tracksetting">\n <label class="vjs-label">Font Size</label>\n <select>\n <option value="0.50">50%</option>\n <option value="0.75">75%</option>\n <option value="1.00" selected>100%</option>\n <option value="1.25">125%</option>\n <option value="1.50">150%</option>\n <option value="1.75">175%</option>\n <option value="2.00">200%</option>\n <option value="3.00">300%</option>\n <option value="4.00">400%</option>\n </select>\n </div> <!-- vjs-font-percent -->\n <div class="vjs-edge-style vjs-tracksetting">\n <label class="vjs-label">Text Edge Style</label>\n <select>\n <option value="none">None</option>\n <option value="raised">Raised</option>\n <option value="depressed">Depressed</option>\n <option value="uniform">Uniform</option>\n <option value="dropshadow">Dropshadow</option>\n </select>\n </div> <!-- vjs-edge-style -->\n <div class="vjs-font-family vjs-tracksetting">\n <label class="vjs-label">Font Family</label>\n <select>\n <option value="">Default</option>\n <option value="monospaceSerif">Monospace Serif</option>\n <option value="proportionalSerif">Proportional Serif</option>\n <option value="monospaceSansSerif">Monospace Sans-Serif</option>\n <option value="proportionalSansSerif">Proportional Sans-Serif</option>\n <option value="casual">Casual</option>\n <option value="script">Script</option>\n <option value="small-caps">Small Caps</option>\n </select>\n </div> <!-- vjs-font-family -->\n </div>\n </div>\n <div class="vjs-tracksettings-controls">\n <button class="vjs-default-button">Defaults</button>\n <button class="vjs-done-button">Done</button>\n </div>';
|
|
|
|
return template;
|
|
}
|
|
|
|
exports['default'] = TextTrackSettings;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../component":67,"../utils/events.js":144,"../utils/fn.js":145,"../utils/log.js":148,"global/window":2,"safe-json-parse/tuple":54}],134:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file text-track.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _textTrackCueList = _dereq_('./text-track-cue-list');
|
|
|
|
var _textTrackCueList2 = _interopRequireDefault(_textTrackCueList);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _trackEnums = _dereq_('./track-enums');
|
|
|
|
var _utilsLogJs = _dereq_('../utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _trackJs = _dereq_('./track.js');
|
|
|
|
var _trackJs2 = _interopRequireDefault(_trackJs);
|
|
|
|
var _utilsUrlJs = _dereq_('../utils/url.js');
|
|
|
|
var _xhr = _dereq_('xhr');
|
|
|
|
var _xhr2 = _interopRequireDefault(_xhr);
|
|
|
|
var _utilsMergeOptions = _dereq_('../utils/merge-options');
|
|
|
|
var _utilsMergeOptions2 = _interopRequireDefault(_utilsMergeOptions);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
/**
|
|
* takes a webvtt file contents and parses it into cues
|
|
*
|
|
* @param {String} srcContent webVTT file contents
|
|
* @param {Track} track track to addcues to
|
|
*/
|
|
var parseCues = function parseCues(srcContent, track) {
|
|
var parser = new _globalWindow2['default'].WebVTT.Parser(_globalWindow2['default'], _globalWindow2['default'].vttjs, _globalWindow2['default'].WebVTT.StringDecoder());
|
|
var errors = [];
|
|
|
|
parser.oncue = function (cue) {
|
|
track.addCue(cue);
|
|
};
|
|
|
|
parser.onparsingerror = function (error) {
|
|
errors.push(error);
|
|
};
|
|
|
|
parser.onflush = function () {
|
|
track.trigger({
|
|
type: 'loadeddata',
|
|
target: track
|
|
});
|
|
};
|
|
|
|
parser.parse(srcContent);
|
|
if (errors.length > 0) {
|
|
if (console.groupCollapsed) {
|
|
console.groupCollapsed('Text Track parsing errors for ' + track.src);
|
|
}
|
|
errors.forEach(function (error) {
|
|
return _utilsLogJs2['default'].error(error);
|
|
});
|
|
if (console.groupEnd) {
|
|
console.groupEnd();
|
|
}
|
|
}
|
|
|
|
parser.flush();
|
|
};
|
|
|
|
/**
|
|
* load a track from a specifed url
|
|
*
|
|
* @param {String} src url to load track from
|
|
* @param {Track} track track to addcues to
|
|
*/
|
|
var loadTrack = function loadTrack(src, track) {
|
|
var opts = {
|
|
uri: src
|
|
};
|
|
var crossOrigin = _utilsUrlJs.isCrossOrigin(src);
|
|
|
|
if (crossOrigin) {
|
|
opts.cors = crossOrigin;
|
|
}
|
|
|
|
_xhr2['default'](opts, Fn.bind(this, function (err, response, responseBody) {
|
|
if (err) {
|
|
return _utilsLogJs2['default'].error(err, response);
|
|
}
|
|
|
|
track.loaded_ = true;
|
|
|
|
// Make sure that vttjs has loaded, otherwise, wait till it finished loading
|
|
// NOTE: this is only used for the alt/video.novtt.js build
|
|
if (typeof _globalWindow2['default'].WebVTT !== 'function') {
|
|
if (track.tech_) {
|
|
(function () {
|
|
var loadHandler = function loadHandler() {
|
|
return parseCues(responseBody, track);
|
|
};
|
|
track.tech_.on('vttjsloaded', loadHandler);
|
|
track.tech_.on('vttjserror', function () {
|
|
_utilsLogJs2['default'].error('vttjs failed to load, stopping trying to process ' + track.src);
|
|
track.tech_.off('vttjsloaded', loadHandler);
|
|
});
|
|
})();
|
|
}
|
|
} else {
|
|
parseCues(responseBody, track);
|
|
}
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* A single text track as defined in:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#texttrack
|
|
*
|
|
* interface TextTrack : EventTarget {
|
|
* readonly attribute TextTrackKind kind;
|
|
* readonly attribute DOMString label;
|
|
* readonly attribute DOMString language;
|
|
*
|
|
* readonly attribute DOMString id;
|
|
* readonly attribute DOMString inBandMetadataTrackDispatchType;
|
|
*
|
|
* attribute TextTrackMode mode;
|
|
*
|
|
* readonly attribute TextTrackCueList? cues;
|
|
* readonly attribute TextTrackCueList? activeCues;
|
|
*
|
|
* void addCue(TextTrackCue cue);
|
|
* void removeCue(TextTrackCue cue);
|
|
*
|
|
* attribute EventHandler oncuechange;
|
|
* };
|
|
*
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends Track
|
|
* @class TextTrack
|
|
*/
|
|
|
|
var TextTrack = (function (_Track) {
|
|
_inherits(TextTrack, _Track);
|
|
|
|
function TextTrack() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
_classCallCheck(this, TextTrack);
|
|
|
|
if (!options.tech) {
|
|
throw new Error('A tech was not provided.');
|
|
}
|
|
|
|
var settings = _utilsMergeOptions2['default'](options, {
|
|
kind: _trackEnums.TextTrackKind[options.kind] || 'subtitles',
|
|
language: options.language || options.srclang || ''
|
|
});
|
|
var mode = _trackEnums.TextTrackMode[settings.mode] || 'disabled';
|
|
var default_ = settings['default'];
|
|
|
|
if (settings.kind === 'metadata' || settings.kind === 'chapters') {
|
|
mode = 'hidden';
|
|
}
|
|
// on IE8 this will be a document element
|
|
// for every other browser this will be a normal object
|
|
var tt = _Track.call(this, settings);
|
|
tt.tech_ = settings.tech;
|
|
|
|
if (browser.IS_IE8) {
|
|
for (var prop in TextTrack.prototype) {
|
|
if (prop !== 'constructor') {
|
|
tt[prop] = TextTrack.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
tt.cues_ = [];
|
|
tt.activeCues_ = [];
|
|
|
|
var cues = new _textTrackCueList2['default'](tt.cues_);
|
|
var activeCues = new _textTrackCueList2['default'](tt.activeCues_);
|
|
var changed = false;
|
|
var timeupdateHandler = Fn.bind(tt, function () {
|
|
this.activeCues;
|
|
if (changed) {
|
|
this.trigger('cuechange');
|
|
changed = false;
|
|
}
|
|
});
|
|
|
|
if (mode !== 'disabled') {
|
|
tt.tech_.on('timeupdate', timeupdateHandler);
|
|
}
|
|
|
|
Object.defineProperty(tt, 'default', {
|
|
get: function get() {
|
|
return default_;
|
|
},
|
|
set: function set() {}
|
|
});
|
|
|
|
Object.defineProperty(tt, 'mode', {
|
|
get: function get() {
|
|
return mode;
|
|
},
|
|
set: function set(newMode) {
|
|
if (!_trackEnums.TextTrackMode[newMode]) {
|
|
return;
|
|
}
|
|
mode = newMode;
|
|
if (mode === 'showing') {
|
|
this.tech_.on('timeupdate', timeupdateHandler);
|
|
}
|
|
this.trigger('modechange');
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(tt, 'cues', {
|
|
get: function get() {
|
|
if (!this.loaded_) {
|
|
return null;
|
|
}
|
|
|
|
return cues;
|
|
},
|
|
set: function set() {}
|
|
});
|
|
|
|
Object.defineProperty(tt, 'activeCues', {
|
|
get: function get() {
|
|
if (!this.loaded_) {
|
|
return null;
|
|
}
|
|
|
|
// nothing to do
|
|
if (this.cues.length === 0) {
|
|
return activeCues;
|
|
}
|
|
|
|
var ct = this.tech_.currentTime();
|
|
var active = [];
|
|
|
|
for (var i = 0, l = this.cues.length; i < l; i++) {
|
|
var cue = this.cues[i];
|
|
|
|
if (cue.startTime <= ct && cue.endTime >= ct) {
|
|
active.push(cue);
|
|
} else if (cue.startTime === cue.endTime && cue.startTime <= ct && cue.startTime + 0.5 >= ct) {
|
|
active.push(cue);
|
|
}
|
|
}
|
|
|
|
changed = false;
|
|
|
|
if (active.length !== this.activeCues_.length) {
|
|
changed = true;
|
|
} else {
|
|
for (var i = 0; i < active.length; i++) {
|
|
if (this.activeCues_.indexOf(active[i]) === -1) {
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.activeCues_ = active;
|
|
activeCues.setCues_(this.activeCues_);
|
|
|
|
return activeCues;
|
|
},
|
|
set: function set() {}
|
|
});
|
|
|
|
if (settings.src) {
|
|
tt.src = settings.src;
|
|
loadTrack(settings.src, tt);
|
|
} else {
|
|
tt.loaded_ = true;
|
|
}
|
|
|
|
return tt;
|
|
}
|
|
|
|
/**
|
|
* cuechange - One or more cues in the track have become active or stopped being active.
|
|
*/
|
|
|
|
/**
|
|
* add a cue to the internal list of cues
|
|
*
|
|
* @param {Object} cue the cue to add to our internal list
|
|
* @method addCue
|
|
*/
|
|
|
|
TextTrack.prototype.addCue = function addCue(cue) {
|
|
var tracks = this.tech_.textTracks();
|
|
|
|
if (tracks) {
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
if (tracks[i] !== this) {
|
|
tracks[i].removeCue(cue);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.cues_.push(cue);
|
|
this.cues.setCues_(this.cues_);
|
|
};
|
|
|
|
/**
|
|
* remvoe a cue from our internal list
|
|
*
|
|
* @param {Object} removeCue the cue to remove from our internal list
|
|
* @method removeCue
|
|
*/
|
|
|
|
TextTrack.prototype.removeCue = function removeCue(_removeCue) {
|
|
var removed = false;
|
|
|
|
for (var i = 0, l = this.cues_.length; i < l; i++) {
|
|
var cue = this.cues_[i];
|
|
|
|
if (cue === _removeCue) {
|
|
this.cues_.splice(i, 1);
|
|
removed = true;
|
|
}
|
|
}
|
|
|
|
if (removed) {
|
|
this.cues.setCues_(this.cues_);
|
|
}
|
|
};
|
|
|
|
return TextTrack;
|
|
})(_trackJs2['default']);
|
|
|
|
TextTrack.prototype.allowedEvents_ = {
|
|
cuechange: 'cuechange'
|
|
};
|
|
|
|
exports['default'] = TextTrack;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"../utils/fn.js":145,"../utils/log.js":148,"../utils/merge-options":149,"../utils/url.js":153,"./text-track-cue-list":129,"./track-enums":135,"./track.js":137,"global/document":1,"global/window":2,"xhr":56}],135:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file track-kinds.js
|
|
*/
|
|
|
|
/**
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#dom-videotrack-kind
|
|
*
|
|
* enum VideoTrackKind {
|
|
* "alternative",
|
|
* "captions",
|
|
* "main",
|
|
* "sign",
|
|
* "subtitles",
|
|
* "commentary",
|
|
* "",
|
|
* };
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
var VideoTrackKind = {
|
|
alternative: 'alternative',
|
|
captions: 'captions',
|
|
main: 'main',
|
|
sign: 'sign',
|
|
subtitles: 'subtitles',
|
|
commentary: 'commentary'
|
|
};
|
|
|
|
/**
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#dom-audiotrack-kind
|
|
*
|
|
* enum AudioTrackKind {
|
|
* "alternative",
|
|
* "descriptions",
|
|
* "main",
|
|
* "main-desc",
|
|
* "translation",
|
|
* "commentary",
|
|
* "",
|
|
* };
|
|
*/
|
|
var AudioTrackKind = {
|
|
alternative: 'alternative',
|
|
descriptions: 'descriptions',
|
|
main: 'main',
|
|
'main-desc': 'main-desc',
|
|
translation: 'translation',
|
|
commentary: 'commentary'
|
|
};
|
|
|
|
/**
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#texttrackkind
|
|
*
|
|
* enum TextTrackKind {
|
|
* "subtitles",
|
|
* "captions",
|
|
* "descriptions",
|
|
* "chapters",
|
|
* "metadata"
|
|
* };
|
|
*/
|
|
var TextTrackKind = {
|
|
subtitles: 'subtitles',
|
|
captions: 'captions',
|
|
descriptions: 'descriptions',
|
|
chapters: 'chapters',
|
|
metadata: 'metadata'
|
|
};
|
|
|
|
/**
|
|
* https://html.spec.whatwg.org/multipage/embedded-content.html#texttrackmode
|
|
*
|
|
* enum TextTrackMode { "disabled", "hidden", "showing" };
|
|
*/
|
|
var TextTrackMode = {
|
|
disabled: 'disabled',
|
|
hidden: 'hidden',
|
|
showing: 'showing'
|
|
};
|
|
|
|
/* jshint ignore:start */
|
|
// we ignore jshint here because it does not see
|
|
// AudioTrackKind as defined here
|
|
exports['default'] = { VideoTrackKind: VideoTrackKind, AudioTrackKind: AudioTrackKind, TextTrackKind: TextTrackKind, TextTrackMode: TextTrackMode };
|
|
|
|
/* jshint ignore:end */
|
|
module.exports = exports['default'];
|
|
|
|
},{}],136:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file track-list.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _eventTarget = _dereq_('../event-target');
|
|
|
|
var _eventTarget2 = _interopRequireDefault(_eventTarget);
|
|
|
|
var _utilsFnJs = _dereq_('../utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* Common functionaliy between Text, Audio, and Video TrackLists
|
|
* Interfaces defined in the following spec:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html
|
|
*
|
|
* @param {Track[]} tracks A list of tracks to initialize the list with
|
|
* @param {Object} list the child object with inheritance done manually for ie8
|
|
* @extends EventTarget
|
|
* @class TrackList
|
|
*/
|
|
|
|
var TrackList = (function (_EventTarget) {
|
|
_inherits(TrackList, _EventTarget);
|
|
|
|
function TrackList() {
|
|
var tracks = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
var list = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
|
|
|
|
_classCallCheck(this, TrackList);
|
|
|
|
_EventTarget.call(this);
|
|
if (!list) {
|
|
list = this;
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
for (var prop in TrackList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = TrackList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
list.tracks_ = [];
|
|
Object.defineProperty(list, 'length', {
|
|
get: function get() {
|
|
return this.tracks_.length;
|
|
}
|
|
});
|
|
|
|
for (var i = 0; i < tracks.length; i++) {
|
|
list.addTrack_(tracks[i]);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* change - One or more tracks in the track list have been enabled or disabled.
|
|
* addtrack - A track has been added to the track list.
|
|
* removetrack - A track has been removed from the track list.
|
|
*/
|
|
|
|
/**
|
|
* Add a Track from TrackList
|
|
*
|
|
* @param {Mixed} track
|
|
* @method addTrack_
|
|
* @private
|
|
*/
|
|
|
|
TrackList.prototype.addTrack_ = function addTrack_(track) {
|
|
var index = this.tracks_.length;
|
|
|
|
if (!('' + index in this)) {
|
|
Object.defineProperty(this, index, {
|
|
get: function get() {
|
|
return this.tracks_[index];
|
|
}
|
|
});
|
|
}
|
|
|
|
// Do not add duplicate tracks
|
|
if (this.tracks_.indexOf(track) === -1) {
|
|
this.tracks_.push(track);
|
|
this.trigger({
|
|
track: track,
|
|
type: 'addtrack'
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Remove a Track from TrackList
|
|
*
|
|
* @param {Track} rtrack track to be removed
|
|
* @method removeTrack_
|
|
* @private
|
|
*/
|
|
|
|
TrackList.prototype.removeTrack_ = function removeTrack_(rtrack) {
|
|
var track = undefined;
|
|
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
if (this[i] === rtrack) {
|
|
track = this[i];
|
|
if (track.off) {
|
|
track.off();
|
|
}
|
|
|
|
this.tracks_.splice(i, 1);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!track) {
|
|
return;
|
|
}
|
|
|
|
this.trigger({
|
|
track: track,
|
|
type: 'removetrack'
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get a Track from the TrackList by a tracks id
|
|
*
|
|
* @param {String} id - the id of the track to get
|
|
* @method getTrackById
|
|
* @return {Track}
|
|
* @private
|
|
*/
|
|
|
|
TrackList.prototype.getTrackById = function getTrackById(id) {
|
|
var result = null;
|
|
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
var track = this[i];
|
|
if (track.id === id) {
|
|
result = track;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
return TrackList;
|
|
})(_eventTarget2['default']);
|
|
|
|
TrackList.prototype.allowedEvents_ = {
|
|
change: 'change',
|
|
addtrack: 'addtrack',
|
|
removetrack: 'removetrack'
|
|
};
|
|
|
|
// emulate attribute EventHandler support to allow for feature detection
|
|
for (var _event in TrackList.prototype.allowedEvents_) {
|
|
TrackList.prototype['on' + _event] = null;
|
|
}
|
|
|
|
exports['default'] = TrackList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../event-target":104,"../utils/browser.js":140,"../utils/fn.js":145,"global/document":1}],137:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file track.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
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 _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _utilsGuidJs = _dereq_('../utils/guid.js');
|
|
|
|
var Guid = _interopRequireWildcard(_utilsGuidJs);
|
|
|
|
var _eventTarget = _dereq_('../event-target');
|
|
|
|
var _eventTarget2 = _interopRequireDefault(_eventTarget);
|
|
|
|
/**
|
|
* setup the common parts of an audio, video, or text track
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html
|
|
*
|
|
* @param {String} type The type of track we are dealing with audio|video|text
|
|
* @param {Object=} options Object of option names and values
|
|
* @extends EventTarget
|
|
* @class Track
|
|
*/
|
|
|
|
var Track = (function (_EventTarget) {
|
|
_inherits(Track, _EventTarget);
|
|
|
|
function Track() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
_classCallCheck(this, Track);
|
|
|
|
_EventTarget.call(this);
|
|
|
|
var track = this;
|
|
if (browser.IS_IE8) {
|
|
track = _globalDocument2['default'].createElement('custom');
|
|
for (var prop in Track.prototype) {
|
|
if (prop !== 'constructor') {
|
|
track[prop] = Track.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
var trackProps = {
|
|
id: options.id || 'vjs_track_' + Guid.newGUID(),
|
|
kind: options.kind || '',
|
|
label: options.label || '',
|
|
language: options.language || ''
|
|
};
|
|
|
|
var _loop = function (key) {
|
|
Object.defineProperty(track, key, {
|
|
get: function get() {
|
|
return trackProps[key];
|
|
},
|
|
set: function set() {}
|
|
});
|
|
};
|
|
|
|
for (var key in trackProps) {
|
|
_loop(key);
|
|
}
|
|
|
|
return track;
|
|
}
|
|
|
|
return Track;
|
|
})(_eventTarget2['default']);
|
|
|
|
exports['default'] = Track;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../event-target":104,"../utils/browser.js":140,"../utils/guid.js":147,"global/document":1}],138:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file video-track-list.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackList = _dereq_('./track-list');
|
|
|
|
var _trackList2 = _interopRequireDefault(_trackList);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* disable other video tracks before selecting the new one
|
|
*
|
|
* @param {Array|VideoTrackList} list list to work on
|
|
* @param {VideoTrack} track the track to skip
|
|
*/
|
|
var disableOthers = function disableOthers(list, track) {
|
|
for (var i = 0; i < list.length; i++) {
|
|
if (track.id === list[i].id) {
|
|
continue;
|
|
}
|
|
// another audio track is enabled, disable it
|
|
list[i].selected = false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A list of possiblee video tracks. Most functionality is in the
|
|
* base class Tracklist and the spec for VideoTrackList is located at:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#videotracklist
|
|
*
|
|
* interface VideoTrackList : EventTarget {
|
|
* readonly attribute unsigned long length;
|
|
* getter VideoTrack (unsigned long index);
|
|
* VideoTrack? getTrackById(DOMString id);
|
|
* readonly attribute long selectedIndex;
|
|
*
|
|
* attribute EventHandler onchange;
|
|
* attribute EventHandler onaddtrack;
|
|
* attribute EventHandler onremovetrack;
|
|
* };
|
|
*
|
|
* @param {VideoTrack[]} tracks a list of video tracks to instantiate the list with
|
|
# @extends TrackList
|
|
* @class VideoTrackList
|
|
*/
|
|
|
|
var VideoTrackList = (function (_TrackList) {
|
|
_inherits(VideoTrackList, _TrackList);
|
|
|
|
function VideoTrackList() {
|
|
var tracks = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
|
|
|
|
_classCallCheck(this, VideoTrackList);
|
|
|
|
var list = undefined;
|
|
|
|
// make sure only 1 track is enabled
|
|
// sorted from last index to first index
|
|
for (var i = tracks.length - 1; i >= 0; i--) {
|
|
if (tracks[i].selected) {
|
|
disableOthers(tracks, tracks[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// IE8 forces us to implement inheritance ourselves
|
|
// as it does not support Object.defineProperty properly
|
|
if (browser.IS_IE8) {
|
|
list = _globalDocument2['default'].createElement('custom');
|
|
for (var prop in _trackList2['default'].prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = _trackList2['default'].prototype[prop];
|
|
}
|
|
}
|
|
for (var prop in VideoTrackList.prototype) {
|
|
if (prop !== 'constructor') {
|
|
list[prop] = VideoTrackList.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
list = _TrackList.call(this, tracks, list);
|
|
list.changing_ = false;
|
|
|
|
Object.defineProperty(list, 'selectedIndex', {
|
|
get: function get() {
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (this[i].selected) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
},
|
|
set: function set() {}
|
|
});
|
|
|
|
return list;
|
|
}
|
|
|
|
VideoTrackList.prototype.addTrack_ = function addTrack_(track) {
|
|
var _this = this;
|
|
|
|
if (track.selected) {
|
|
disableOthers(this, track);
|
|
}
|
|
|
|
_TrackList.prototype.addTrack_.call(this, track);
|
|
// native tracks don't have this
|
|
if (!track.addEventListener) {
|
|
return;
|
|
}
|
|
track.addEventListener('selectedchange', function () {
|
|
if (_this.changing_) {
|
|
return;
|
|
}
|
|
_this.changing_ = true;
|
|
disableOthers(_this, track);
|
|
_this.changing_ = false;
|
|
_this.trigger('change');
|
|
});
|
|
};
|
|
|
|
VideoTrackList.prototype.addTrack = function addTrack(track) {
|
|
this.addTrack_(track);
|
|
};
|
|
|
|
VideoTrackList.prototype.removeTrack = function removeTrack(track) {
|
|
_TrackList.prototype.removeTrack_.call(this, track);
|
|
};
|
|
|
|
return VideoTrackList;
|
|
})(_trackList2['default']);
|
|
|
|
exports['default'] = VideoTrackList;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"./track-list":136,"global/document":1}],139:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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 _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 _trackEnums = _dereq_('./track-enums');
|
|
|
|
var _track = _dereq_('./track');
|
|
|
|
var _track2 = _interopRequireDefault(_track);
|
|
|
|
var _utilsMergeOptions = _dereq_('../utils/merge-options');
|
|
|
|
var _utilsMergeOptions2 = _interopRequireDefault(_utilsMergeOptions);
|
|
|
|
var _utilsBrowserJs = _dereq_('../utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
/**
|
|
* A single video text track as defined in:
|
|
* @link https://html.spec.whatwg.org/multipage/embedded-content.html#videotrack
|
|
*
|
|
* interface VideoTrack {
|
|
* readonly attribute DOMString id;
|
|
* readonly attribute DOMString kind;
|
|
* readonly attribute DOMString label;
|
|
* readonly attribute DOMString language;
|
|
* attribute boolean selected;
|
|
* };
|
|
*
|
|
* @param {Object=} options Object of option names and values
|
|
* @class VideoTrack
|
|
*/
|
|
|
|
var VideoTrack = (function (_Track) {
|
|
_inherits(VideoTrack, _Track);
|
|
|
|
function VideoTrack() {
|
|
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
_classCallCheck(this, VideoTrack);
|
|
|
|
var settings = _utilsMergeOptions2['default'](options, {
|
|
kind: _trackEnums.VideoTrackKind[options.kind] || ''
|
|
});
|
|
|
|
// on IE8 this will be a document element
|
|
// for every other browser this will be a normal object
|
|
var track = _Track.call(this, settings);
|
|
var selected = false;
|
|
|
|
if (browser.IS_IE8) {
|
|
for (var prop in VideoTrack.prototype) {
|
|
if (prop !== 'constructor') {
|
|
track[prop] = VideoTrack.prototype[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(track, 'selected', {
|
|
get: function get() {
|
|
return selected;
|
|
},
|
|
set: function set(newSelected) {
|
|
// an invalid or unchanged value
|
|
if (typeof newSelected !== 'boolean' || newSelected === selected) {
|
|
return;
|
|
}
|
|
selected = newSelected;
|
|
this.trigger('selectedchange');
|
|
}
|
|
});
|
|
|
|
// if the user sets this track to selected then
|
|
// set selected to that true value otherwise
|
|
// we keep it false
|
|
if (settings.selected) {
|
|
track.selected = settings.selected;
|
|
}
|
|
|
|
return track;
|
|
}
|
|
|
|
return VideoTrack;
|
|
})(_track2['default']);
|
|
|
|
exports['default'] = VideoTrack;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../utils/browser.js":140,"../utils/merge-options":149,"./track":137,"./track-enums":135}],140:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file browser.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var USER_AGENT = _globalWindow2['default'].navigator.userAgent;
|
|
var webkitVersionMap = /AppleWebKit\/([\d.]+)/i.exec(USER_AGENT);
|
|
var appleWebkitVersion = webkitVersionMap ? parseFloat(webkitVersionMap.pop()) : null;
|
|
|
|
/*
|
|
* Device is an iPhone
|
|
*
|
|
* @type {Boolean}
|
|
* @constant
|
|
* @private
|
|
*/
|
|
var IS_IPAD = /iPad/i.test(USER_AGENT);
|
|
|
|
exports.IS_IPAD = IS_IPAD;
|
|
// The Facebook app's UIWebView identifies as both an iPhone and iPad, so
|
|
// to identify iPhones, we need to exclude iPads.
|
|
// http://artsy.github.io/blog/2012/10/18/the-perils-of-ios-user-agent-sniffing/
|
|
var IS_IPHONE = /iPhone/i.test(USER_AGENT) && !IS_IPAD;
|
|
exports.IS_IPHONE = IS_IPHONE;
|
|
var IS_IPOD = /iPod/i.test(USER_AGENT);
|
|
exports.IS_IPOD = IS_IPOD;
|
|
var IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
|
|
|
|
exports.IS_IOS = IS_IOS;
|
|
var IOS_VERSION = (function () {
|
|
var match = USER_AGENT.match(/OS (\d+)_/i);
|
|
if (match && match[1]) {
|
|
return match[1];
|
|
}
|
|
})();
|
|
|
|
exports.IOS_VERSION = IOS_VERSION;
|
|
var IS_ANDROID = /Android/i.test(USER_AGENT);
|
|
exports.IS_ANDROID = IS_ANDROID;
|
|
var ANDROID_VERSION = (function () {
|
|
// This matches Android Major.Minor.Patch versions
|
|
// ANDROID_VERSION is Major.Minor as a Number, if Minor isn't available, then only Major is returned
|
|
var match = USER_AGENT.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i),
|
|
major,
|
|
minor;
|
|
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
|
|
major = match[1] && parseFloat(match[1]);
|
|
minor = match[2] && parseFloat(match[2]);
|
|
|
|
if (major && minor) {
|
|
return parseFloat(match[1] + '.' + match[2]);
|
|
} else if (major) {
|
|
return major;
|
|
} else {
|
|
return null;
|
|
}
|
|
})();
|
|
exports.ANDROID_VERSION = ANDROID_VERSION;
|
|
// Old Android is defined as Version older than 2.3, and requiring a webkit version of the android browser
|
|
var IS_OLD_ANDROID = IS_ANDROID && /webkit/i.test(USER_AGENT) && ANDROID_VERSION < 2.3;
|
|
exports.IS_OLD_ANDROID = IS_OLD_ANDROID;
|
|
var IS_NATIVE_ANDROID = IS_ANDROID && ANDROID_VERSION < 5 && appleWebkitVersion < 537;
|
|
|
|
exports.IS_NATIVE_ANDROID = IS_NATIVE_ANDROID;
|
|
var IS_FIREFOX = /Firefox/i.test(USER_AGENT);
|
|
exports.IS_FIREFOX = IS_FIREFOX;
|
|
var IS_EDGE = /Edge/i.test(USER_AGENT);
|
|
exports.IS_EDGE = IS_EDGE;
|
|
var IS_CHROME = !IS_EDGE && /Chrome/i.test(USER_AGENT);
|
|
exports.IS_CHROME = IS_CHROME;
|
|
var IS_IE8 = /MSIE\s8\.0/.test(USER_AGENT);
|
|
|
|
exports.IS_IE8 = IS_IE8;
|
|
var TOUCH_ENABLED = !!('ontouchstart' in _globalWindow2['default'] || _globalWindow2['default'].DocumentTouch && _globalDocument2['default'] instanceof _globalWindow2['default'].DocumentTouch);
|
|
exports.TOUCH_ENABLED = TOUCH_ENABLED;
|
|
var BACKGROUND_SIZE_SUPPORTED = ('backgroundSize' in _globalDocument2['default'].createElement('video').style);
|
|
exports.BACKGROUND_SIZE_SUPPORTED = BACKGROUND_SIZE_SUPPORTED;
|
|
|
|
},{"global/document":1,"global/window":2}],141:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file buffer.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.bufferedPercent = bufferedPercent;
|
|
|
|
var _timeRangesJs = _dereq_('./time-ranges.js');
|
|
|
|
/**
|
|
* Compute how much your video has been buffered
|
|
*
|
|
* @param {Object} Buffered object
|
|
* @param {Number} Total duration
|
|
* @return {Number} Percent buffered of the total duration
|
|
* @private
|
|
* @function bufferedPercent
|
|
*/
|
|
|
|
function bufferedPercent(buffered, duration) {
|
|
var bufferedDuration = 0,
|
|
start,
|
|
end;
|
|
|
|
if (!duration) {
|
|
return 0;
|
|
}
|
|
|
|
if (!buffered || !buffered.length) {
|
|
buffered = _timeRangesJs.createTimeRange(0, 0);
|
|
}
|
|
|
|
for (var i = 0; i < buffered.length; i++) {
|
|
start = buffered.start(i);
|
|
end = buffered.end(i);
|
|
|
|
// buffered end can be bigger than duration by a very small fraction
|
|
if (end > duration) {
|
|
end = duration;
|
|
}
|
|
|
|
bufferedDuration += end - start;
|
|
}
|
|
|
|
return bufferedDuration / duration;
|
|
}
|
|
|
|
},{"./time-ranges.js":151}],142:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _logJs = _dereq_('./log.js');
|
|
|
|
var _logJs2 = _interopRequireDefault(_logJs);
|
|
|
|
/**
|
|
* Object containing the default behaviors for available handler methods.
|
|
*
|
|
* @private
|
|
* @type {Object}
|
|
*/
|
|
var defaultBehaviors = {
|
|
get: function get(obj, key) {
|
|
return obj[key];
|
|
},
|
|
set: function set(obj, key, value) {
|
|
obj[key] = value;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Expose private objects publicly using a Proxy to log deprecation warnings.
|
|
*
|
|
* Browsers that do not support Proxy objects will simply return the `target`
|
|
* object, so it can be directly exposed.
|
|
*
|
|
* @param {Object} target The target object.
|
|
* @param {Object} messages Messages to display from a Proxy. Only operations
|
|
* with an associated message will be proxied.
|
|
* @param {String} [messages.get]
|
|
* @param {String} [messages.set]
|
|
* @return {Object} A Proxy if supported or the `target` argument.
|
|
*/
|
|
|
|
exports['default'] = function (target) {
|
|
var messages = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
|
|
if (typeof Proxy === 'function') {
|
|
var _ret = (function () {
|
|
var handler = {};
|
|
|
|
// Build a handler object based on those keys that have both messages
|
|
// and default behaviors.
|
|
Object.keys(messages).forEach(function (key) {
|
|
if (defaultBehaviors.hasOwnProperty(key)) {
|
|
handler[key] = function () {
|
|
_logJs2['default'].warn(messages[key]);
|
|
return defaultBehaviors[key].apply(this, arguments);
|
|
};
|
|
}
|
|
});
|
|
|
|
return {
|
|
v: new Proxy(target, handler)
|
|
};
|
|
})();
|
|
|
|
if (typeof _ret === 'object') return _ret.v;
|
|
}
|
|
return target;
|
|
};
|
|
|
|
module.exports = exports['default'];
|
|
|
|
},{"./log.js":148}],143:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file dom.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.getEl = getEl;
|
|
exports.createEl = createEl;
|
|
exports.textContent = textContent;
|
|
exports.insertElFirst = insertElFirst;
|
|
exports.getElData = getElData;
|
|
exports.hasElData = hasElData;
|
|
exports.removeElData = removeElData;
|
|
exports.hasElClass = hasElClass;
|
|
exports.addElClass = addElClass;
|
|
exports.removeElClass = removeElClass;
|
|
exports.toggleElClass = toggleElClass;
|
|
exports.setElAttributes = setElAttributes;
|
|
exports.getElAttributes = getElAttributes;
|
|
exports.blockTextSelection = blockTextSelection;
|
|
exports.unblockTextSelection = unblockTextSelection;
|
|
exports.findElPosition = findElPosition;
|
|
exports.getPointerPosition = getPointerPosition;
|
|
exports.isEl = isEl;
|
|
exports.isTextNode = isTextNode;
|
|
exports.emptyEl = emptyEl;
|
|
exports.normalizeContent = normalizeContent;
|
|
exports.appendContent = appendContent;
|
|
exports.insertContent = insertContent;
|
|
|
|
var _templateObject = _taggedTemplateLiteralLoose(['Setting attributes in the second argument of createEl()\n has been deprecated. Use the third argument instead.\n createEl(type, properties, attributes). Attempting to set ', ' to ', '.'], ['Setting attributes in the second argument of createEl()\n has been deprecated. Use the third argument instead.\n createEl(type, properties, attributes). Attempting to set ', ' to ', '.']);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _taggedTemplateLiteralLoose(strings, raw) { strings.raw = raw; return strings; }
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _guidJs = _dereq_('./guid.js');
|
|
|
|
var Guid = _interopRequireWildcard(_guidJs);
|
|
|
|
var _logJs = _dereq_('./log.js');
|
|
|
|
var _logJs2 = _interopRequireDefault(_logJs);
|
|
|
|
var _tsml = _dereq_('tsml');
|
|
|
|
var _tsml2 = _interopRequireDefault(_tsml);
|
|
|
|
/**
|
|
* Detect if a value is a string with any non-whitespace characters.
|
|
*
|
|
* @param {String} str
|
|
* @return {Boolean}
|
|
*/
|
|
function isNonBlankString(str) {
|
|
return typeof str === 'string' && /\S/.test(str);
|
|
}
|
|
|
|
/**
|
|
* Throws an error if the passed string has whitespace. This is used by
|
|
* class methods to be relatively consistent with the classList API.
|
|
*
|
|
* @param {String} str
|
|
* @return {Boolean}
|
|
*/
|
|
function throwIfWhitespace(str) {
|
|
if (/\s/.test(str)) {
|
|
throw new Error('class has illegal whitespace characters');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Produce a regular expression for matching a class name.
|
|
*
|
|
* @param {String} className
|
|
* @return {RegExp}
|
|
*/
|
|
function classRegExp(className) {
|
|
return new RegExp('(^|\\s)' + className + '($|\\s)');
|
|
}
|
|
|
|
/**
|
|
* Creates functions to query the DOM using a given method.
|
|
*
|
|
* @function createQuerier
|
|
* @private
|
|
* @param {String} method
|
|
* @return {Function}
|
|
*/
|
|
function createQuerier(method) {
|
|
return function (selector, context) {
|
|
if (!isNonBlankString(selector)) {
|
|
return _globalDocument2['default'][method](null);
|
|
}
|
|
if (isNonBlankString(context)) {
|
|
context = _globalDocument2['default'].querySelector(context);
|
|
}
|
|
return (isEl(context) ? context : _globalDocument2['default'])[method](selector);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Shorthand for document.getElementById()
|
|
* Also allows for CSS (jQuery) ID syntax. But nothing other than IDs.
|
|
*
|
|
* @param {String} id Element ID
|
|
* @return {Element} Element with supplied ID
|
|
* @function getEl
|
|
*/
|
|
|
|
function getEl(id) {
|
|
if (id.indexOf('#') === 0) {
|
|
id = id.slice(1);
|
|
}
|
|
|
|
return _globalDocument2['default'].getElementById(id);
|
|
}
|
|
|
|
/**
|
|
* Creates an element and applies properties.
|
|
*
|
|
* @param {String} [tagName='div'] Name of tag to be created.
|
|
* @param {Object} [properties={}] Element properties to be applied.
|
|
* @param {Object} [attributes={}] Element attributes to be applied.
|
|
* @return {Element}
|
|
* @function createEl
|
|
*/
|
|
|
|
function createEl() {
|
|
var tagName = arguments.length <= 0 || arguments[0] === undefined ? 'div' : arguments[0];
|
|
var properties = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
|
var attributes = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
|
|
|
var el = _globalDocument2['default'].createElement(tagName);
|
|
|
|
Object.getOwnPropertyNames(properties).forEach(function (propName) {
|
|
var val = properties[propName];
|
|
|
|
// See #2176
|
|
// We originally were accepting both properties and attributes in the
|
|
// same object, but that doesn't work so well.
|
|
if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
|
|
_logJs2['default'].warn(_tsml2['default'](_templateObject, propName, val));
|
|
el.setAttribute(propName, val);
|
|
} else {
|
|
el[propName] = val;
|
|
}
|
|
});
|
|
|
|
Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
|
|
var val = attributes[attrName];
|
|
el.setAttribute(attrName, attributes[attrName]);
|
|
});
|
|
|
|
return el;
|
|
}
|
|
|
|
/**
|
|
* Injects text into an element, replacing any existing contents entirely.
|
|
*
|
|
* @param {Element} el
|
|
* @param {String} text
|
|
* @return {Element}
|
|
* @function textContent
|
|
*/
|
|
|
|
function textContent(el, text) {
|
|
if (typeof el.textContent === 'undefined') {
|
|
el.innerText = text;
|
|
} else {
|
|
el.textContent = text;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert an element as the first child node of another
|
|
*
|
|
* @param {Element} child Element to insert
|
|
* @param {Element} parent Element to insert child into
|
|
* @private
|
|
* @function insertElFirst
|
|
*/
|
|
|
|
function insertElFirst(child, parent) {
|
|
if (parent.firstChild) {
|
|
parent.insertBefore(child, parent.firstChild);
|
|
} else {
|
|
parent.appendChild(child);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Element Data Store. Allows for binding data to an element without putting it directly on the element.
|
|
* Ex. Event listeners are stored here.
|
|
* (also from jsninja.com, slightly modified and updated for closure compiler)
|
|
*
|
|
* @type {Object}
|
|
* @private
|
|
*/
|
|
var elData = {};
|
|
|
|
/*
|
|
* Unique attribute name to store an element's guid in
|
|
*
|
|
* @type {String}
|
|
* @constant
|
|
* @private
|
|
*/
|
|
var elIdAttr = 'vdata' + new Date().getTime();
|
|
|
|
/**
|
|
* Returns the cache object where data for an element is stored
|
|
*
|
|
* @param {Element} el Element to store data for.
|
|
* @return {Object}
|
|
* @function getElData
|
|
*/
|
|
|
|
function getElData(el) {
|
|
var id = el[elIdAttr];
|
|
|
|
if (!id) {
|
|
id = el[elIdAttr] = Guid.newGUID();
|
|
}
|
|
|
|
if (!elData[id]) {
|
|
elData[id] = {};
|
|
}
|
|
|
|
return elData[id];
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not an element has cached data
|
|
*
|
|
* @param {Element} el A dom element
|
|
* @return {Boolean}
|
|
* @private
|
|
* @function hasElData
|
|
*/
|
|
|
|
function hasElData(el) {
|
|
var id = el[elIdAttr];
|
|
|
|
if (!id) {
|
|
return false;
|
|
}
|
|
|
|
return !!Object.getOwnPropertyNames(elData[id]).length;
|
|
}
|
|
|
|
/**
|
|
* Delete data for the element from the cache and the guid attr from getElementById
|
|
*
|
|
* @param {Element} el Remove data for an element
|
|
* @private
|
|
* @function removeElData
|
|
*/
|
|
|
|
function removeElData(el) {
|
|
var id = el[elIdAttr];
|
|
|
|
if (!id) {
|
|
return;
|
|
}
|
|
|
|
// Remove all stored data
|
|
delete elData[id];
|
|
|
|
// Remove the elIdAttr property from the DOM node
|
|
try {
|
|
delete el[elIdAttr];
|
|
} catch (e) {
|
|
if (el.removeAttribute) {
|
|
el.removeAttribute(elIdAttr);
|
|
} else {
|
|
// IE doesn't appear to support removeAttribute on the document element
|
|
el[elIdAttr] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if an element has a CSS class
|
|
*
|
|
* @function hasElClass
|
|
* @param {Element} element Element to check
|
|
* @param {String} classToCheck Classname to check
|
|
*/
|
|
|
|
function hasElClass(element, classToCheck) {
|
|
if (element.classList) {
|
|
return element.classList.contains(classToCheck);
|
|
} else {
|
|
throwIfWhitespace(classToCheck);
|
|
return classRegExp(classToCheck).test(element.className);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a CSS class name to an element
|
|
*
|
|
* @function addElClass
|
|
* @param {Element} element Element to add class name to
|
|
* @param {String} classToAdd Classname to add
|
|
*/
|
|
|
|
function addElClass(element, classToAdd) {
|
|
if (element.classList) {
|
|
element.classList.add(classToAdd);
|
|
|
|
// Don't need to `throwIfWhitespace` here because `hasElClass` will do it
|
|
// in the case of classList not being supported.
|
|
} else if (!hasElClass(element, classToAdd)) {
|
|
element.className = (element.className + ' ' + classToAdd).trim();
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Remove a CSS class name from an element
|
|
*
|
|
* @function removeElClass
|
|
* @param {Element} element Element to remove from class name
|
|
* @param {String} classToRemove Classname to remove
|
|
*/
|
|
|
|
function removeElClass(element, classToRemove) {
|
|
if (element.classList) {
|
|
element.classList.remove(classToRemove);
|
|
} else {
|
|
throwIfWhitespace(classToRemove);
|
|
element.className = element.className.split(/\s+/).filter(function (c) {
|
|
return c !== classToRemove;
|
|
}).join(' ');
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Adds or removes a CSS class name on an element depending on an optional
|
|
* condition or the presence/absence of the class name.
|
|
*
|
|
* @function toggleElClass
|
|
* @param {Element} element
|
|
* @param {String} classToToggle
|
|
* @param {Boolean|Function} [predicate]
|
|
* Can be a function that returns a Boolean. If `true`, the class
|
|
* will be added; if `false`, the class will be removed. If not
|
|
* given, the class will be added if not present and vice versa.
|
|
*/
|
|
|
|
function toggleElClass(element, classToToggle, predicate) {
|
|
|
|
// This CANNOT use `classList` internally because IE does not support the
|
|
// second parameter to the `classList.toggle()` method! Which is fine because
|
|
// `classList` will be used by the add/remove functions.
|
|
var has = hasElClass(element, classToToggle);
|
|
|
|
if (typeof predicate === 'function') {
|
|
predicate = predicate(element, classToToggle);
|
|
}
|
|
|
|
if (typeof predicate !== 'boolean') {
|
|
predicate = !has;
|
|
}
|
|
|
|
// If the necessary class operation matches the current state of the
|
|
// element, no action is required.
|
|
if (predicate === has) {
|
|
return;
|
|
}
|
|
|
|
if (predicate) {
|
|
addElClass(element, classToToggle);
|
|
} else {
|
|
removeElClass(element, classToToggle);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Apply attributes to an HTML element.
|
|
*
|
|
* @param {Element} el Target element.
|
|
* @param {Object=} attributes Element attributes to be applied.
|
|
* @private
|
|
* @function setElAttributes
|
|
*/
|
|
|
|
function setElAttributes(el, attributes) {
|
|
Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
|
|
var attrValue = attributes[attrName];
|
|
|
|
if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
|
|
el.removeAttribute(attrName);
|
|
} else {
|
|
el.setAttribute(attrName, attrValue === true ? '' : attrValue);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get an element's attribute values, as defined on the HTML tag
|
|
* Attributes are not the same as properties. They're defined on the tag
|
|
* or with setAttribute (which shouldn't be used with HTML)
|
|
* This will return true or false for boolean attributes.
|
|
*
|
|
* @param {Element} tag Element from which to get tag attributes
|
|
* @return {Object}
|
|
* @private
|
|
* @function getElAttributes
|
|
*/
|
|
|
|
function getElAttributes(tag) {
|
|
var obj, knownBooleans, attrs, attrName, attrVal;
|
|
|
|
obj = {};
|
|
|
|
// known boolean attributes
|
|
// we can check for matching boolean properties, but older browsers
|
|
// won't know about HTML5 boolean attributes that we still read from
|
|
knownBooleans = ',' + 'autoplay,controls,loop,muted,default' + ',';
|
|
|
|
if (tag && tag.attributes && tag.attributes.length > 0) {
|
|
attrs = tag.attributes;
|
|
|
|
for (var i = attrs.length - 1; i >= 0; i--) {
|
|
attrName = attrs[i].name;
|
|
attrVal = attrs[i].value;
|
|
|
|
// check for known booleans
|
|
// the matching element property will return a value for typeof
|
|
if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
|
|
// the value of an included boolean attribute is typically an empty
|
|
// string ('') which would equal false if we just check for a false value.
|
|
// we also don't want support bad code like autoplay='false'
|
|
attrVal = attrVal !== null ? true : false;
|
|
}
|
|
|
|
obj[attrName] = attrVal;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Attempt to block the ability to select text while dragging controls
|
|
*
|
|
* @return {Boolean}
|
|
* @function blockTextSelection
|
|
*/
|
|
|
|
function blockTextSelection() {
|
|
_globalDocument2['default'].body.focus();
|
|
_globalDocument2['default'].onselectstart = function () {
|
|
return false;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Turn off text selection blocking
|
|
*
|
|
* @return {Boolean}
|
|
* @function unblockTextSelection
|
|
*/
|
|
|
|
function unblockTextSelection() {
|
|
_globalDocument2['default'].onselectstart = function () {
|
|
return true;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Offset Left
|
|
* getBoundingClientRect technique from
|
|
* John Resig http://ejohn.org/blog/getboundingclientrect-is-awesome/
|
|
*
|
|
* @function findElPosition
|
|
* @param {Element} el Element from which to get offset
|
|
* @return {Object}
|
|
*/
|
|
|
|
function findElPosition(el) {
|
|
var box = undefined;
|
|
|
|
if (el.getBoundingClientRect && el.parentNode) {
|
|
box = el.getBoundingClientRect();
|
|
}
|
|
|
|
if (!box) {
|
|
return {
|
|
left: 0,
|
|
top: 0
|
|
};
|
|
}
|
|
|
|
var docEl = _globalDocument2['default'].documentElement;
|
|
var body = _globalDocument2['default'].body;
|
|
|
|
var clientLeft = docEl.clientLeft || body.clientLeft || 0;
|
|
var scrollLeft = _globalWindow2['default'].pageXOffset || body.scrollLeft;
|
|
var left = box.left + scrollLeft - clientLeft;
|
|
|
|
var clientTop = docEl.clientTop || body.clientTop || 0;
|
|
var scrollTop = _globalWindow2['default'].pageYOffset || body.scrollTop;
|
|
var top = box.top + scrollTop - clientTop;
|
|
|
|
// Android sometimes returns slightly off decimal values, so need to round
|
|
return {
|
|
left: Math.round(left),
|
|
top: Math.round(top)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get pointer position in element
|
|
* Returns an object with x and y coordinates.
|
|
* The base on the coordinates are the bottom left of the element.
|
|
*
|
|
* @function getPointerPosition
|
|
* @param {Element} el Element on which to get the pointer position on
|
|
* @param {Event} event Event object
|
|
* @return {Object} This object will have x and y coordinates corresponding to the mouse position
|
|
*/
|
|
|
|
function getPointerPosition(el, event) {
|
|
var position = {};
|
|
var box = findElPosition(el);
|
|
var boxW = el.offsetWidth;
|
|
var boxH = el.offsetHeight;
|
|
|
|
var boxY = box.top;
|
|
var boxX = box.left;
|
|
var pageY = event.pageY;
|
|
var pageX = event.pageX;
|
|
|
|
if (event.changedTouches) {
|
|
pageX = event.changedTouches[0].pageX;
|
|
pageY = event.changedTouches[0].pageY;
|
|
}
|
|
|
|
position.y = Math.max(0, Math.min(1, (boxY - pageY + boxH) / boxH));
|
|
position.x = Math.max(0, Math.min(1, (pageX - boxX) / boxW));
|
|
|
|
return position;
|
|
}
|
|
|
|
/**
|
|
* Determines, via duck typing, whether or not a value is a DOM element.
|
|
*
|
|
* @function isEl
|
|
* @param {Mixed} value
|
|
* @return {Boolean}
|
|
*/
|
|
|
|
function isEl(value) {
|
|
return !!value && typeof value === 'object' && value.nodeType === 1;
|
|
}
|
|
|
|
/**
|
|
* Determines, via duck typing, whether or not a value is a text node.
|
|
*
|
|
* @param {Mixed} value
|
|
* @return {Boolean}
|
|
*/
|
|
|
|
function isTextNode(value) {
|
|
return !!value && typeof value === 'object' && value.nodeType === 3;
|
|
}
|
|
|
|
/**
|
|
* Empties the contents of an element.
|
|
*
|
|
* @function emptyEl
|
|
* @param {Element} el
|
|
* @return {Element}
|
|
*/
|
|
|
|
function emptyEl(el) {
|
|
while (el.firstChild) {
|
|
el.removeChild(el.firstChild);
|
|
}
|
|
return el;
|
|
}
|
|
|
|
/**
|
|
* Normalizes content for eventual insertion into the DOM.
|
|
*
|
|
* This allows a wide range of content definition methods, but protects
|
|
* from falling into the trap of simply writing to `innerHTML`, which is
|
|
* an XSS concern.
|
|
*
|
|
* The content for an element can be passed in multiple types and
|
|
* combinations, whose behavior is as follows:
|
|
*
|
|
* - String
|
|
* Normalized into a text node.
|
|
*
|
|
* - Element, TextNode
|
|
* Passed through.
|
|
*
|
|
* - Array
|
|
* A one-dimensional array of strings, elements, nodes, or functions (which
|
|
* return single strings, elements, or nodes).
|
|
*
|
|
* - Function
|
|
* If the sole argument, is expected to produce a string, element,
|
|
* node, or array.
|
|
*
|
|
* @function normalizeContent
|
|
* @param {String|Element|TextNode|Array|Function} content
|
|
* @return {Array}
|
|
*/
|
|
|
|
function normalizeContent(content) {
|
|
|
|
// First, invoke content if it is a function. If it produces an array,
|
|
// that needs to happen before normalization.
|
|
if (typeof content === 'function') {
|
|
content = content();
|
|
}
|
|
|
|
// Next up, normalize to an array, so one or many items can be normalized,
|
|
// filtered, and returned.
|
|
return (Array.isArray(content) ? content : [content]).map(function (value) {
|
|
|
|
// First, invoke value if it is a function to produce a new value,
|
|
// which will be subsequently normalized to a Node of some kind.
|
|
if (typeof value === 'function') {
|
|
value = value();
|
|
}
|
|
|
|
if (isEl(value) || isTextNode(value)) {
|
|
return value;
|
|
}
|
|
|
|
if (typeof value === 'string' && /\S/.test(value)) {
|
|
return _globalDocument2['default'].createTextNode(value);
|
|
}
|
|
}).filter(function (value) {
|
|
return value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Normalizes and appends content to an element.
|
|
*
|
|
* @function appendContent
|
|
* @param {Element} el
|
|
* @param {String|Element|TextNode|Array|Function} content
|
|
* See: `normalizeContent`
|
|
* @return {Element}
|
|
*/
|
|
|
|
function appendContent(el, content) {
|
|
normalizeContent(content).forEach(function (node) {
|
|
return el.appendChild(node);
|
|
});
|
|
return el;
|
|
}
|
|
|
|
/**
|
|
* Normalizes and inserts content into an element; this is identical to
|
|
* `appendContent()`, except it empties the element first.
|
|
*
|
|
* @function insertContent
|
|
* @param {Element} el
|
|
* @param {String|Element|TextNode|Array|Function} content
|
|
* See: `normalizeContent`
|
|
* @return {Element}
|
|
*/
|
|
|
|
function insertContent(el, content) {
|
|
return appendContent(emptyEl(el), content);
|
|
}
|
|
|
|
/**
|
|
* Finds a single DOM element matching `selector` within the optional
|
|
* `context` of another DOM element (defaulting to `document`).
|
|
*
|
|
* @function $
|
|
* @param {String} selector
|
|
* A valid CSS selector, which will be passed to `querySelector`.
|
|
*
|
|
* @param {Element|String} [context=document]
|
|
* A DOM element within which to query. Can also be a selector
|
|
* string in which case the first matching element will be used
|
|
* as context. If missing (or no element matches selector), falls
|
|
* back to `document`.
|
|
*
|
|
* @return {Element|null}
|
|
*/
|
|
var $ = createQuerier('querySelector');
|
|
|
|
exports.$ = $;
|
|
/**
|
|
* Finds a all DOM elements matching `selector` within the optional
|
|
* `context` of another DOM element (defaulting to `document`).
|
|
*
|
|
* @function $$
|
|
* @param {String} selector
|
|
* A valid CSS selector, which will be passed to `querySelectorAll`.
|
|
*
|
|
* @param {Element|String} [context=document]
|
|
* A DOM element within which to query. Can also be a selector
|
|
* string in which case the first matching element will be used
|
|
* as context. If missing (or no element matches selector), falls
|
|
* back to `document`.
|
|
*
|
|
* @return {NodeList}
|
|
*/
|
|
var $$ = createQuerier('querySelectorAll');
|
|
exports.$$ = $$;
|
|
|
|
},{"./guid.js":147,"./log.js":148,"global/document":1,"global/window":2,"tsml":55}],144:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file events.js
|
|
*
|
|
* Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
|
|
* (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
|
|
* This should work very similarly to jQuery's events, however it's based off the book version which isn't as
|
|
* robust as jquery's, so there's probably some differences.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.on = on;
|
|
exports.off = off;
|
|
exports.trigger = trigger;
|
|
exports.one = one;
|
|
exports.fixEvent = fixEvent;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
var _domJs = _dereq_('./dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_domJs);
|
|
|
|
var _guidJs = _dereq_('./guid.js');
|
|
|
|
var Guid = _interopRequireWildcard(_guidJs);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* Add an event listener to element
|
|
* It stores the handler function in a separate cache object
|
|
* and adds a generic handler to the element's event,
|
|
* along with a unique id (guid) to the element.
|
|
*
|
|
* @param {Element|Object} elem Element or object to bind listeners to
|
|
* @param {String|Array} type Type of event to bind to.
|
|
* @param {Function} fn Event listener.
|
|
* @method on
|
|
*/
|
|
|
|
function on(elem, type, fn) {
|
|
if (Array.isArray(type)) {
|
|
return _handleMultipleEvents(on, elem, type, fn);
|
|
}
|
|
|
|
var data = Dom.getElData(elem);
|
|
|
|
// We need a place to store all our handler data
|
|
if (!data.handlers) data.handlers = {};
|
|
|
|
if (!data.handlers[type]) data.handlers[type] = [];
|
|
|
|
if (!fn.guid) fn.guid = Guid.newGUID();
|
|
|
|
data.handlers[type].push(fn);
|
|
|
|
if (!data.dispatcher) {
|
|
data.disabled = false;
|
|
|
|
data.dispatcher = function (event, hash) {
|
|
|
|
if (data.disabled) return;
|
|
event = fixEvent(event);
|
|
|
|
var handlers = data.handlers[event.type];
|
|
|
|
if (handlers) {
|
|
// Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
|
|
var handlersCopy = handlers.slice(0);
|
|
|
|
for (var m = 0, n = handlersCopy.length; m < n; m++) {
|
|
if (event.isImmediatePropagationStopped()) {
|
|
break;
|
|
} else {
|
|
handlersCopy[m].call(elem, event, hash);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
if (data.handlers[type].length === 1) {
|
|
if (elem.addEventListener) {
|
|
elem.addEventListener(type, data.dispatcher, false);
|
|
} else if (elem.attachEvent) {
|
|
elem.attachEvent('on' + type, data.dispatcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes event listeners from an element
|
|
*
|
|
* @param {Element|Object} elem Object to remove listeners from
|
|
* @param {String|Array=} type Type of listener to remove. Don't include to remove all events from element.
|
|
* @param {Function} fn Specific listener to remove. Don't include to remove listeners for an event type.
|
|
* @method off
|
|
*/
|
|
|
|
function off(elem, type, fn) {
|
|
// Don't want to add a cache object through getElData if not needed
|
|
if (!Dom.hasElData(elem)) return;
|
|
|
|
var data = Dom.getElData(elem);
|
|
|
|
// If no events exist, nothing to unbind
|
|
if (!data.handlers) {
|
|
return;
|
|
}
|
|
|
|
if (Array.isArray(type)) {
|
|
return _handleMultipleEvents(off, elem, type, fn);
|
|
}
|
|
|
|
// Utility function
|
|
var removeType = function removeType(t) {
|
|
data.handlers[t] = [];
|
|
_cleanUpEvents(elem, t);
|
|
};
|
|
|
|
// Are we removing all bound events?
|
|
if (!type) {
|
|
for (var t in data.handlers) {
|
|
removeType(t);
|
|
}return;
|
|
}
|
|
|
|
var handlers = data.handlers[type];
|
|
|
|
// If no handlers exist, nothing to unbind
|
|
if (!handlers) return;
|
|
|
|
// If no listener was provided, remove all listeners for type
|
|
if (!fn) {
|
|
removeType(type);
|
|
return;
|
|
}
|
|
|
|
// We're only removing a single handler
|
|
if (fn.guid) {
|
|
for (var n = 0; n < handlers.length; n++) {
|
|
if (handlers[n].guid === fn.guid) {
|
|
handlers.splice(n--, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
_cleanUpEvents(elem, type);
|
|
}
|
|
|
|
/**
|
|
* Trigger an event for an element
|
|
*
|
|
* @param {Element|Object} elem Element to trigger an event on
|
|
* @param {Event|Object|String} event A string (the type) or an event object with a type attribute
|
|
* @param {Object} [hash] data hash to pass along with the event
|
|
* @return {Boolean=} Returned only if default was prevented
|
|
* @method trigger
|
|
*/
|
|
|
|
function trigger(elem, event, hash) {
|
|
// Fetches element data and a reference to the parent (for bubbling).
|
|
// Don't want to add a data object to cache for every parent,
|
|
// so checking hasElData first.
|
|
var elemData = Dom.hasElData(elem) ? Dom.getElData(elem) : {};
|
|
var parent = elem.parentNode || elem.ownerDocument;
|
|
// type = event.type || event,
|
|
// handler;
|
|
|
|
// If an event name was passed as a string, creates an event out of it
|
|
if (typeof event === 'string') {
|
|
event = { type: event, target: elem };
|
|
}
|
|
// Normalizes the event properties.
|
|
event = fixEvent(event);
|
|
|
|
// If the passed element has a dispatcher, executes the established handlers.
|
|
if (elemData.dispatcher) {
|
|
elemData.dispatcher.call(elem, event, hash);
|
|
}
|
|
|
|
// Unless explicitly stopped or the event does not bubble (e.g. media events)
|
|
// recursively calls this function to bubble the event up the DOM.
|
|
if (parent && !event.isPropagationStopped() && event.bubbles === true) {
|
|
trigger.call(null, parent, event, hash);
|
|
|
|
// If at the top of the DOM, triggers the default action unless disabled.
|
|
} else if (!parent && !event.defaultPrevented) {
|
|
var targetData = Dom.getElData(event.target);
|
|
|
|
// Checks if the target has a default action for this event.
|
|
if (event.target[event.type]) {
|
|
// Temporarily disables event dispatching on the target as we have already executed the handler.
|
|
targetData.disabled = true;
|
|
// Executes the default action.
|
|
if (typeof event.target[event.type] === 'function') {
|
|
event.target[event.type]();
|
|
}
|
|
// Re-enables event dispatching.
|
|
targetData.disabled = false;
|
|
}
|
|
}
|
|
|
|
// Inform the triggerer if the default was prevented by returning false
|
|
return !event.defaultPrevented;
|
|
}
|
|
|
|
/**
|
|
* Trigger a listener only once for an event
|
|
*
|
|
* @param {Element|Object} elem Element or object to
|
|
* @param {String|Array} type Name/type of event
|
|
* @param {Function} fn Event handler function
|
|
* @method one
|
|
*/
|
|
|
|
function one(elem, type, fn) {
|
|
if (Array.isArray(type)) {
|
|
return _handleMultipleEvents(one, elem, type, fn);
|
|
}
|
|
var func = function func() {
|
|
off(elem, type, func);
|
|
fn.apply(this, arguments);
|
|
};
|
|
// copy the guid to the new function so it can removed using the original function's ID
|
|
func.guid = fn.guid = fn.guid || Guid.newGUID();
|
|
on(elem, type, func);
|
|
}
|
|
|
|
/**
|
|
* Fix a native event to have standard property values
|
|
*
|
|
* @param {Object} event Event object to fix
|
|
* @return {Object}
|
|
* @private
|
|
* @method fixEvent
|
|
*/
|
|
|
|
function fixEvent(event) {
|
|
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
|
|
// Test if fixing up is needed
|
|
// Used to check if !event.stopPropagation instead of isPropagationStopped
|
|
// But native events return true for stopPropagation, but don't have
|
|
// other expected methods like isPropagationStopped. Seems to be a problem
|
|
// with the Javascript Ninja code. So we're just overriding all events now.
|
|
if (!event || !event.isPropagationStopped) {
|
|
var old = event || _globalWindow2['default'].event;
|
|
|
|
event = {};
|
|
// Clone the old object so that we can modify the values event = {};
|
|
// IE8 Doesn't like when you mess with native event properties
|
|
// Firefox returns false for event.hasOwnProperty('type') and other props
|
|
// which makes copying more difficult.
|
|
// TODO: Probably best to create a whitelist of event props
|
|
for (var key in old) {
|
|
// Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
|
|
// Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
|
|
// and webkitMovementX/Y
|
|
if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
|
|
// Chrome 32+ warns if you try to copy deprecated returnValue, but
|
|
// we still want to if preventDefault isn't supported (IE8).
|
|
if (!(key === 'returnValue' && old.preventDefault)) {
|
|
event[key] = old[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
// The event occurred on this element
|
|
if (!event.target) {
|
|
event.target = event.srcElement || _globalDocument2['default'];
|
|
}
|
|
|
|
// Handle which other element the event is related to
|
|
if (!event.relatedTarget) {
|
|
event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
|
|
}
|
|
|
|
// Stop the default browser action
|
|
event.preventDefault = function () {
|
|
if (old.preventDefault) {
|
|
old.preventDefault();
|
|
}
|
|
event.returnValue = false;
|
|
old.returnValue = false;
|
|
event.defaultPrevented = true;
|
|
};
|
|
|
|
event.defaultPrevented = false;
|
|
|
|
// Stop the event from bubbling
|
|
event.stopPropagation = function () {
|
|
if (old.stopPropagation) {
|
|
old.stopPropagation();
|
|
}
|
|
event.cancelBubble = true;
|
|
old.cancelBubble = true;
|
|
event.isPropagationStopped = returnTrue;
|
|
};
|
|
|
|
event.isPropagationStopped = returnFalse;
|
|
|
|
// Stop the event from bubbling and executing other handlers
|
|
event.stopImmediatePropagation = function () {
|
|
if (old.stopImmediatePropagation) {
|
|
old.stopImmediatePropagation();
|
|
}
|
|
event.isImmediatePropagationStopped = returnTrue;
|
|
event.stopPropagation();
|
|
};
|
|
|
|
event.isImmediatePropagationStopped = returnFalse;
|
|
|
|
// Handle mouse position
|
|
if (event.clientX != null) {
|
|
var doc = _globalDocument2['default'].documentElement,
|
|
body = _globalDocument2['default'].body;
|
|
|
|
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
|
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
|
|
}
|
|
|
|
// Handle key presses
|
|
event.which = event.charCode || event.keyCode;
|
|
|
|
// Fix button for mouse clicks:
|
|
// 0 == left; 1 == middle; 2 == right
|
|
if (event.button != null) {
|
|
event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
|
|
}
|
|
}
|
|
|
|
// Returns fixed-up instance
|
|
return event;
|
|
}
|
|
|
|
/**
|
|
* Clean up the listener cache and dispatchers
|
|
*
|
|
* @param {Element|Object} elem Element to clean up
|
|
* @param {String} type Type of event to clean up
|
|
* @private
|
|
* @method _cleanUpEvents
|
|
*/
|
|
function _cleanUpEvents(elem, type) {
|
|
var data = Dom.getElData(elem);
|
|
|
|
// Remove the events of a particular type if there are none left
|
|
if (data.handlers[type].length === 0) {
|
|
delete data.handlers[type];
|
|
// data.handlers[type] = null;
|
|
// Setting to null was causing an error with data.handlers
|
|
|
|
// Remove the meta-handler from the element
|
|
if (elem.removeEventListener) {
|
|
elem.removeEventListener(type, data.dispatcher, false);
|
|
} else if (elem.detachEvent) {
|
|
elem.detachEvent('on' + type, data.dispatcher);
|
|
}
|
|
}
|
|
|
|
// Remove the events object if there are no types left
|
|
if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
|
|
delete data.handlers;
|
|
delete data.dispatcher;
|
|
delete data.disabled;
|
|
}
|
|
|
|
// Finally remove the element data if there is no data left
|
|
if (Object.getOwnPropertyNames(data).length === 0) {
|
|
Dom.removeElData(elem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loops through an array of event types and calls the requested method for each type.
|
|
*
|
|
* @param {Function} fn The event method we want to use.
|
|
* @param {Element|Object} elem Element or object to bind listeners to
|
|
* @param {String} type Type of event to bind to.
|
|
* @param {Function} callback Event listener.
|
|
* @private
|
|
* @function _handleMultipleEvents
|
|
*/
|
|
function _handleMultipleEvents(fn, elem, types, callback) {
|
|
types.forEach(function (type) {
|
|
//Call the event method for each one of the types
|
|
fn(elem, type, callback);
|
|
});
|
|
}
|
|
|
|
},{"./dom.js":143,"./guid.js":147,"global/document":1,"global/window":2}],145:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file fn.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _guidJs = _dereq_('./guid.js');
|
|
|
|
/**
|
|
* Bind (a.k.a proxy or Context). A simple method for changing the context of a function
|
|
* It also stores a unique id on the function so it can be easily removed from events
|
|
*
|
|
* @param {*} context The object to bind as scope
|
|
* @param {Function} fn The function to be bound to a scope
|
|
* @param {Number=} uid An optional unique ID for the function to be set
|
|
* @return {Function}
|
|
* @private
|
|
* @method bind
|
|
*/
|
|
var bind = function bind(context, fn, uid) {
|
|
// Make sure the function has a unique ID
|
|
if (!fn.guid) {
|
|
fn.guid = _guidJs.newGUID();
|
|
}
|
|
|
|
// Create the new function that changes the context
|
|
var ret = function ret() {
|
|
return fn.apply(context, arguments);
|
|
};
|
|
|
|
// Allow for the ability to individualize this function
|
|
// Needed in the case where multiple objects might share the same prototype
|
|
// IF both items add an event listener with the same function, then you try to remove just one
|
|
// it will remove both because they both have the same guid.
|
|
// when using this, you need to use the bind method when you remove the listener as well.
|
|
// currently used in text tracks
|
|
ret.guid = uid ? uid + '_' + fn.guid : fn.guid;
|
|
|
|
return ret;
|
|
};
|
|
exports.bind = bind;
|
|
|
|
},{"./guid.js":147}],146:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file format-time.js
|
|
*
|
|
* Format seconds as a time string, H:MM:SS or M:SS
|
|
* Supplying a guide (in seconds) will force a number of leading zeros
|
|
* to cover the length of the guide
|
|
*
|
|
* @param {Number} seconds Number of seconds to be turned into a string
|
|
* @param {Number} guide Number (in seconds) to model the string after
|
|
* @return {String} Time formatted as H:MM:SS or M:SS
|
|
* @private
|
|
* @function formatTime
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
function formatTime(seconds) {
|
|
var guide = arguments.length <= 1 || arguments[1] === undefined ? seconds : arguments[1];
|
|
return (function () {
|
|
seconds = seconds < 0 ? 0 : seconds;
|
|
var s = Math.floor(seconds % 60);
|
|
var m = Math.floor(seconds / 60 % 60);
|
|
var h = Math.floor(seconds / 3600);
|
|
var gm = Math.floor(guide / 60 % 60);
|
|
var gh = Math.floor(guide / 3600);
|
|
|
|
// handle invalid times
|
|
if (isNaN(seconds) || seconds === Infinity) {
|
|
// '-' is false for all relational operators (e.g. <, >=) so this setting
|
|
// will add the minimum number of fields specified by the guide
|
|
h = m = s = '-';
|
|
}
|
|
|
|
// Check if we need to show hours
|
|
h = h > 0 || gh > 0 ? h + ':' : '';
|
|
|
|
// If hours are showing, we may need to add a leading zero.
|
|
// Always show at least one digit of minutes.
|
|
m = ((h || gm >= 10) && m < 10 ? '0' + m : m) + ':';
|
|
|
|
// Check if leading zero is need for seconds
|
|
s = s < 10 ? '0' + s : s;
|
|
|
|
return h + m + s;
|
|
})();
|
|
}
|
|
|
|
exports['default'] = formatTime;
|
|
module.exports = exports['default'];
|
|
|
|
},{}],147:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file guid.js
|
|
*
|
|
* Unique ID for an element or function
|
|
* @type {Number}
|
|
* @private
|
|
*/
|
|
"use strict";
|
|
|
|
exports.__esModule = true;
|
|
exports.newGUID = newGUID;
|
|
var _guid = 1;
|
|
|
|
/**
|
|
* Get the next unique ID
|
|
*
|
|
* @return {String}
|
|
* @function newGUID
|
|
*/
|
|
|
|
function newGUID() {
|
|
return _guid++;
|
|
}
|
|
|
|
},{}],148:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file log.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
/**
|
|
* Log plain debug messages
|
|
*/
|
|
var log = function log() {
|
|
_logType(null, arguments);
|
|
};
|
|
|
|
/**
|
|
* Keep a history of log messages
|
|
* @type {Array}
|
|
*/
|
|
log.history = [];
|
|
|
|
/**
|
|
* Log error messages
|
|
*/
|
|
log.error = function () {
|
|
_logType('error', arguments);
|
|
};
|
|
|
|
/**
|
|
* Log warning messages
|
|
*/
|
|
log.warn = function () {
|
|
_logType('warn', arguments);
|
|
};
|
|
|
|
/**
|
|
* Log messages to the console and history based on the type of message
|
|
*
|
|
* @param {String} type The type of message, or `null` for `log`
|
|
* @param {Object} args The args to be passed to the log
|
|
* @private
|
|
* @method _logType
|
|
*/
|
|
function _logType(type, args) {
|
|
// convert args to an array to get array functions
|
|
var argsArray = Array.prototype.slice.call(args);
|
|
// if there's no console then don't try to output messages
|
|
// they will still be stored in log.history
|
|
// Was setting these once outside of this function, but containing them
|
|
// in the function makes it easier to test cases where console doesn't exist
|
|
var noop = function noop() {};
|
|
|
|
var console = _globalWindow2['default']['console'] || {
|
|
'log': noop,
|
|
'warn': noop,
|
|
'error': noop
|
|
};
|
|
|
|
if (type) {
|
|
// add the type to the front of the message
|
|
argsArray.unshift(type.toUpperCase() + ':');
|
|
} else {
|
|
// default to log with no prefix
|
|
type = 'log';
|
|
}
|
|
|
|
// add to history
|
|
log.history.push(argsArray);
|
|
|
|
// add console prefix after adding to history
|
|
argsArray.unshift('VIDEOJS:');
|
|
|
|
// call appropriate log function
|
|
if (console[type].apply) {
|
|
console[type].apply(console, argsArray);
|
|
} else {
|
|
// ie8 doesn't allow error.apply, but it will just join() the array anyway
|
|
console[type](argsArray.join(' '));
|
|
}
|
|
}
|
|
|
|
exports['default'] = log;
|
|
module.exports = exports['default'];
|
|
|
|
},{"global/window":2}],149:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file merge-options.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports['default'] = mergeOptions;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _lodashCompatObjectMerge = _dereq_('lodash-compat/object/merge');
|
|
|
|
var _lodashCompatObjectMerge2 = _interopRequireDefault(_lodashCompatObjectMerge);
|
|
|
|
function isPlain(obj) {
|
|
return !!obj && typeof obj === 'object' && obj.toString() === '[object Object]' && obj.constructor === Object;
|
|
}
|
|
|
|
/**
|
|
* Merge customizer. video.js simply overwrites non-simple objects
|
|
* (like arrays) instead of attempting to overlay them.
|
|
* @see https://lodash.com/docs#merge
|
|
*/
|
|
var customizer = function customizer(destination, source) {
|
|
// If we're not working with a plain object, copy the value as is
|
|
// If source is an array, for instance, it will replace destination
|
|
if (!isPlain(source)) {
|
|
return source;
|
|
}
|
|
|
|
// If the new value is a plain object but the first object value is not
|
|
// we need to create a new object for the first object to merge with.
|
|
// This makes it consistent with how merge() works by default
|
|
// and also protects from later changes the to first object affecting
|
|
// the second object's values.
|
|
if (!isPlain(destination)) {
|
|
return mergeOptions(source);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Merge one or more options objects, recursively merging **only**
|
|
* plain object properties. Previously `deepMerge`.
|
|
*
|
|
* @param {...Object} source One or more objects to merge
|
|
* @returns {Object} a new object that is the union of all
|
|
* provided objects
|
|
* @function mergeOptions
|
|
*/
|
|
|
|
function mergeOptions() {
|
|
// contruct the call dynamically to handle the variable number of
|
|
// objects to merge
|
|
var args = Array.prototype.slice.call(arguments);
|
|
|
|
// unshift an empty object into the front of the call as the target
|
|
// of the merge
|
|
args.unshift({});
|
|
|
|
// customize conflict resolution to match our historical merge behavior
|
|
args.push(customizer);
|
|
|
|
_lodashCompatObjectMerge2['default'].apply(null, args);
|
|
|
|
// return the mutated result object
|
|
return args[0];
|
|
}
|
|
|
|
module.exports = exports['default'];
|
|
|
|
},{"lodash-compat/object/merge":40}],150:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var createStyleElement = function createStyleElement(className) {
|
|
var style = _globalDocument2['default'].createElement('style');
|
|
style.className = className;
|
|
|
|
return style;
|
|
};
|
|
|
|
exports.createStyleElement = createStyleElement;
|
|
var setTextContent = function setTextContent(el, content) {
|
|
if (el.styleSheet) {
|
|
el.styleSheet.cssText = content;
|
|
} else {
|
|
el.textContent = content;
|
|
}
|
|
};
|
|
exports.setTextContent = setTextContent;
|
|
|
|
},{"global/document":1}],151:[function(_dereq_,module,exports){
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.createTimeRanges = createTimeRanges;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _logJs = _dereq_('./log.js');
|
|
|
|
var _logJs2 = _interopRequireDefault(_logJs);
|
|
|
|
/**
|
|
* @file time-ranges.js
|
|
*
|
|
* Should create a fake TimeRange object
|
|
* Mimics an HTML5 time range instance, which has functions that
|
|
* return the start and end times for a range
|
|
* TimeRanges are returned by the buffered() method
|
|
*
|
|
* @param {(Number|Array)} Start of a single range or an array of ranges
|
|
* @param {Number} End of a single range
|
|
* @private
|
|
* @method createTimeRanges
|
|
*/
|
|
|
|
function createTimeRanges(start, end) {
|
|
if (Array.isArray(start)) {
|
|
return createTimeRangesObj(start);
|
|
} else if (start === undefined || end === undefined) {
|
|
return createTimeRangesObj();
|
|
}
|
|
return createTimeRangesObj([[start, end]]);
|
|
}
|
|
|
|
exports.createTimeRange = createTimeRanges;
|
|
|
|
function createTimeRangesObj(ranges) {
|
|
if (ranges === undefined || ranges.length === 0) {
|
|
return {
|
|
length: 0,
|
|
start: function start() {
|
|
throw new Error('This TimeRanges object is empty');
|
|
},
|
|
end: function end() {
|
|
throw new Error('This TimeRanges object is empty');
|
|
}
|
|
};
|
|
}
|
|
return {
|
|
length: ranges.length,
|
|
start: getRange.bind(null, 'start', 0, ranges),
|
|
end: getRange.bind(null, 'end', 1, ranges)
|
|
};
|
|
}
|
|
|
|
function getRange(fnName, valueIndex, ranges, rangeIndex) {
|
|
if (rangeIndex === undefined) {
|
|
_logJs2['default'].warn('DEPRECATED: Function \'' + fnName + '\' on \'TimeRanges\' called without an index argument.');
|
|
rangeIndex = 0;
|
|
}
|
|
rangeCheck(fnName, rangeIndex, ranges.length - 1);
|
|
return ranges[rangeIndex][valueIndex];
|
|
}
|
|
|
|
function rangeCheck(fnName, index, maxIndex) {
|
|
if (index < 0 || index > maxIndex) {
|
|
throw new Error('Failed to execute \'' + fnName + '\' on \'TimeRanges\': The index provided (' + index + ') is greater than or equal to the maximum bound (' + maxIndex + ').');
|
|
}
|
|
}
|
|
|
|
},{"./log.js":148}],152:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file to-title-case.js
|
|
*
|
|
* Uppercase the first letter of a string
|
|
*
|
|
* @param {String} string String to be uppercased
|
|
* @return {String}
|
|
* @private
|
|
* @method toTitleCase
|
|
*/
|
|
"use strict";
|
|
|
|
exports.__esModule = true;
|
|
function toTitleCase(string) {
|
|
return string.charAt(0).toUpperCase() + string.slice(1);
|
|
}
|
|
|
|
exports["default"] = toTitleCase;
|
|
module.exports = exports["default"];
|
|
|
|
},{}],153:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file url.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
/**
|
|
* Resolve and parse the elements of a URL
|
|
*
|
|
* @param {String} url The url to parse
|
|
* @return {Object} An object of url details
|
|
* @method parseUrl
|
|
*/
|
|
var parseUrl = function parseUrl(url) {
|
|
var props = ['protocol', 'hostname', 'port', 'pathname', 'search', 'hash', 'host'];
|
|
|
|
// add the url to an anchor and let the browser parse the URL
|
|
var a = _globalDocument2['default'].createElement('a');
|
|
a.href = url;
|
|
|
|
// IE8 (and 9?) Fix
|
|
// ie8 doesn't parse the URL correctly until the anchor is actually
|
|
// added to the body, and an innerHTML is needed to trigger the parsing
|
|
var addToBody = a.host === '' && a.protocol !== 'file:';
|
|
var div = undefined;
|
|
if (addToBody) {
|
|
div = _globalDocument2['default'].createElement('div');
|
|
div.innerHTML = '<a href="' + url + '"></a>';
|
|
a = div.firstChild;
|
|
// prevent the div from affecting layout
|
|
div.setAttribute('style', 'display:none; position:absolute;');
|
|
_globalDocument2['default'].body.appendChild(div);
|
|
}
|
|
|
|
// Copy the specific URL properties to a new object
|
|
// This is also needed for IE8 because the anchor loses its
|
|
// properties when it's removed from the dom
|
|
var details = {};
|
|
for (var i = 0; i < props.length; i++) {
|
|
details[props[i]] = a[props[i]];
|
|
}
|
|
|
|
// IE9 adds the port to the host property unlike everyone else. If
|
|
// a port identifier is added for standard ports, strip it.
|
|
if (details.protocol === 'http:') {
|
|
details.host = details.host.replace(/:80$/, '');
|
|
}
|
|
if (details.protocol === 'https:') {
|
|
details.host = details.host.replace(/:443$/, '');
|
|
}
|
|
|
|
if (addToBody) {
|
|
_globalDocument2['default'].body.removeChild(div);
|
|
}
|
|
|
|
return details;
|
|
};
|
|
|
|
exports.parseUrl = parseUrl;
|
|
/**
|
|
* Get absolute version of relative URL. Used to tell flash correct URL.
|
|
* http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
|
|
*
|
|
* @param {String} url URL to make absolute
|
|
* @return {String} Absolute URL
|
|
* @private
|
|
* @method getAbsoluteURL
|
|
*/
|
|
var getAbsoluteURL = function getAbsoluteURL(url) {
|
|
// Check if absolute URL
|
|
if (!url.match(/^https?:\/\//)) {
|
|
// Convert to absolute URL. Flash hosted off-site needs an absolute URL.
|
|
var div = _globalDocument2['default'].createElement('div');
|
|
div.innerHTML = '<a href="' + url + '">x</a>';
|
|
url = div.firstChild.href;
|
|
}
|
|
|
|
return url;
|
|
};
|
|
|
|
exports.getAbsoluteURL = getAbsoluteURL;
|
|
/**
|
|
* Returns the extension of the passed file name. It will return an empty string if you pass an invalid path
|
|
*
|
|
* @param {String} path The fileName path like '/path/to/file.mp4'
|
|
* @returns {String} The extension in lower case or an empty string if no extension could be found.
|
|
* @method getFileExtension
|
|
*/
|
|
var getFileExtension = function getFileExtension(path) {
|
|
if (typeof path === 'string') {
|
|
var splitPathRe = /^(\/?)([\s\S]*?)((?:\.{1,2}|[^\/]+?)(\.([^\.\/\?]+)))(?:[\/]*|[\?].*)$/i;
|
|
var pathParts = splitPathRe.exec(path);
|
|
|
|
if (pathParts) {
|
|
return pathParts.pop().toLowerCase();
|
|
}
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
exports.getFileExtension = getFileExtension;
|
|
/**
|
|
* Returns whether the url passed is a cross domain request or not.
|
|
*
|
|
* @param {String} url The url to check
|
|
* @return {Boolean} Whether it is a cross domain request or not
|
|
* @method isCrossOrigin
|
|
*/
|
|
var isCrossOrigin = function isCrossOrigin(url) {
|
|
var winLoc = _globalWindow2['default'].location;
|
|
var urlInfo = parseUrl(url);
|
|
|
|
// IE8 protocol relative urls will return ':' for protocol
|
|
var srcProtocol = urlInfo.protocol === ':' ? winLoc.protocol : urlInfo.protocol;
|
|
|
|
// Check if url is for another domain/origin
|
|
// IE8 doesn't know location.origin, so we won't rely on it here
|
|
var crossOrigin = srcProtocol + urlInfo.host !== winLoc.protocol + winLoc.host;
|
|
|
|
return crossOrigin;
|
|
};
|
|
exports.isCrossOrigin = isCrossOrigin;
|
|
|
|
},{"global/document":1,"global/window":2}],154:[function(_dereq_,module,exports){
|
|
/**
|
|
* @file video.js
|
|
*/
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalWindow = _dereq_('global/window');
|
|
|
|
var _globalWindow2 = _interopRequireDefault(_globalWindow);
|
|
|
|
var _globalDocument = _dereq_('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _setup = _dereq_('./setup');
|
|
|
|
var setup = _interopRequireWildcard(_setup);
|
|
|
|
var _utilsStylesheetJs = _dereq_('./utils/stylesheet.js');
|
|
|
|
var stylesheet = _interopRequireWildcard(_utilsStylesheetJs);
|
|
|
|
var _component = _dereq_('./component');
|
|
|
|
var _component2 = _interopRequireDefault(_component);
|
|
|
|
var _eventTarget = _dereq_('./event-target');
|
|
|
|
var _eventTarget2 = _interopRequireDefault(_eventTarget);
|
|
|
|
var _utilsEventsJs = _dereq_('./utils/events.js');
|
|
|
|
var Events = _interopRequireWildcard(_utilsEventsJs);
|
|
|
|
var _player = _dereq_('./player');
|
|
|
|
var _player2 = _interopRequireDefault(_player);
|
|
|
|
var _pluginsJs = _dereq_('./plugins.js');
|
|
|
|
var _pluginsJs2 = _interopRequireDefault(_pluginsJs);
|
|
|
|
var _srcJsUtilsMergeOptionsJs = _dereq_('../../src/js/utils/merge-options.js');
|
|
|
|
var _srcJsUtilsMergeOptionsJs2 = _interopRequireDefault(_srcJsUtilsMergeOptionsJs);
|
|
|
|
var _utilsFnJs = _dereq_('./utils/fn.js');
|
|
|
|
var Fn = _interopRequireWildcard(_utilsFnJs);
|
|
|
|
var _tracksTextTrackJs = _dereq_('./tracks/text-track.js');
|
|
|
|
var _tracksTextTrackJs2 = _interopRequireDefault(_tracksTextTrackJs);
|
|
|
|
var _tracksAudioTrackJs = _dereq_('./tracks/audio-track.js');
|
|
|
|
var _tracksAudioTrackJs2 = _interopRequireDefault(_tracksAudioTrackJs);
|
|
|
|
var _tracksVideoTrackJs = _dereq_('./tracks/video-track.js');
|
|
|
|
var _tracksVideoTrackJs2 = _interopRequireDefault(_tracksVideoTrackJs);
|
|
|
|
var _objectAssign = _dereq_('object.assign');
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var _utilsTimeRangesJs = _dereq_('./utils/time-ranges.js');
|
|
|
|
var _utilsFormatTimeJs = _dereq_('./utils/format-time.js');
|
|
|
|
var _utilsFormatTimeJs2 = _interopRequireDefault(_utilsFormatTimeJs);
|
|
|
|
var _utilsLogJs = _dereq_('./utils/log.js');
|
|
|
|
var _utilsLogJs2 = _interopRequireDefault(_utilsLogJs);
|
|
|
|
var _utilsDomJs = _dereq_('./utils/dom.js');
|
|
|
|
var Dom = _interopRequireWildcard(_utilsDomJs);
|
|
|
|
var _utilsBrowserJs = _dereq_('./utils/browser.js');
|
|
|
|
var browser = _interopRequireWildcard(_utilsBrowserJs);
|
|
|
|
var _utilsUrlJs = _dereq_('./utils/url.js');
|
|
|
|
var Url = _interopRequireWildcard(_utilsUrlJs);
|
|
|
|
var _extendJs = _dereq_('./extend.js');
|
|
|
|
var _extendJs2 = _interopRequireDefault(_extendJs);
|
|
|
|
var _lodashCompatObjectMerge = _dereq_('lodash-compat/object/merge');
|
|
|
|
var _lodashCompatObjectMerge2 = _interopRequireDefault(_lodashCompatObjectMerge);
|
|
|
|
var _utilsCreateDeprecationProxyJs = _dereq_('./utils/create-deprecation-proxy.js');
|
|
|
|
var _utilsCreateDeprecationProxyJs2 = _interopRequireDefault(_utilsCreateDeprecationProxyJs);
|
|
|
|
var _xhr = _dereq_('xhr');
|
|
|
|
var _xhr2 = _interopRequireDefault(_xhr);
|
|
|
|
// Include the built-in techs
|
|
|
|
var _techTechJs = _dereq_('./tech/tech.js');
|
|
|
|
var _techTechJs2 = _interopRequireDefault(_techTechJs);
|
|
|
|
var _techHtml5Js = _dereq_('./tech/html5.js');
|
|
|
|
var _techHtml5Js2 = _interopRequireDefault(_techHtml5Js);
|
|
|
|
var _techFlashJs = _dereq_('./tech/flash.js');
|
|
|
|
var _techFlashJs2 = _interopRequireDefault(_techFlashJs);
|
|
|
|
// HTML5 Element Shim for IE8
|
|
if (typeof HTMLVideoElement === 'undefined') {
|
|
_globalDocument2['default'].createElement('video');
|
|
_globalDocument2['default'].createElement('audio');
|
|
_globalDocument2['default'].createElement('track');
|
|
}
|
|
|
|
/**
|
|
* Doubles as the main function for users to create a player instance and also
|
|
* the main library object.
|
|
* The `videojs` function can be used to initialize or retrieve a player.
|
|
* ```js
|
|
* var myPlayer = videojs('my_video_id');
|
|
* ```
|
|
*
|
|
* @param {String|Element} id Video element or video element ID
|
|
* @param {Object=} options Optional options object for config/settings
|
|
* @param {Function=} ready Optional ready callback
|
|
* @return {Player} A player instance
|
|
* @mixes videojs
|
|
* @method videojs
|
|
*/
|
|
var videojs = function videojs(id, options, ready) {
|
|
var tag = undefined; // Element of ID
|
|
|
|
// Allow for element or ID to be passed in
|
|
// String ID
|
|
if (typeof id === 'string') {
|
|
|
|
// Adjust for jQuery ID syntax
|
|
if (id.indexOf('#') === 0) {
|
|
id = id.slice(1);
|
|
}
|
|
|
|
// If a player instance has already been created for this ID return it.
|
|
if (videojs.getPlayers()[id]) {
|
|
|
|
// If options or ready funtion are passed, warn
|
|
if (options) {
|
|
_utilsLogJs2['default'].warn('Player "' + id + '" is already initialised. Options will not be applied.');
|
|
}
|
|
|
|
if (ready) {
|
|
videojs.getPlayers()[id].ready(ready);
|
|
}
|
|
|
|
return videojs.getPlayers()[id];
|
|
|
|
// Otherwise get element for ID
|
|
} else {
|
|
tag = Dom.getEl(id);
|
|
}
|
|
|
|
// ID is a media element
|
|
} else {
|
|
tag = id;
|
|
}
|
|
|
|
// Check for a useable element
|
|
if (!tag || !tag.nodeName) {
|
|
// re: nodeName, could be a box div also
|
|
throw new TypeError('The element or ID supplied is not valid. (videojs)'); // Returns
|
|
}
|
|
|
|
// Element may have a player attr referring to an already created player instance.
|
|
// If not, set up a new player and return the instance.
|
|
return tag['player'] || _player2['default'].players[tag.playerId] || new _player2['default'](tag, options, ready);
|
|
};
|
|
|
|
// Add default styles
|
|
if (_globalWindow2['default'].VIDEOJS_NO_DYNAMIC_STYLE !== true) {
|
|
var style = Dom.$('.vjs-styles-defaults');
|
|
|
|
if (!style) {
|
|
style = stylesheet.createStyleElement('vjs-styles-defaults');
|
|
var head = Dom.$('head');
|
|
head.insertBefore(style, head.firstChild);
|
|
stylesheet.setTextContent(style, '\n .video-js {\n width: 300px;\n height: 150px;\n }\n\n .vjs-fluid {\n padding-top: 56.25%\n }\n ');
|
|
}
|
|
}
|
|
|
|
// Run Auto-load players
|
|
// You have to wait at least once in case this script is loaded after your video in the DOM (weird behavior only with minified version)
|
|
setup.autoSetupTimeout(1, videojs);
|
|
|
|
/*
|
|
* Current software version (semver)
|
|
*
|
|
* @type {String}
|
|
*/
|
|
videojs.VERSION = '5.10.2';
|
|
|
|
/**
|
|
* The global options object. These are the settings that take effect
|
|
* if no overrides are specified when the player is created.
|
|
*
|
|
* ```js
|
|
* videojs.options.autoplay = true
|
|
* // -> all players will autoplay by default
|
|
* ```
|
|
*
|
|
* @type {Object}
|
|
*/
|
|
videojs.options = _player2['default'].prototype.options_;
|
|
|
|
/**
|
|
* Get an object with the currently created players, keyed by player ID
|
|
*
|
|
* @return {Object} The created players
|
|
* @mixes videojs
|
|
* @method getPlayers
|
|
*/
|
|
videojs.getPlayers = function () {
|
|
return _player2['default'].players;
|
|
};
|
|
|
|
/**
|
|
* For backward compatibility, expose players object.
|
|
*
|
|
* @deprecated
|
|
* @memberOf videojs
|
|
* @property {Object|Proxy} players
|
|
*/
|
|
videojs.players = _utilsCreateDeprecationProxyJs2['default'](_player2['default'].players, {
|
|
get: 'Access to videojs.players is deprecated; use videojs.getPlayers instead',
|
|
set: 'Modification of videojs.players is deprecated'
|
|
});
|
|
|
|
/**
|
|
* Get a component class object by name
|
|
* ```js
|
|
* var VjsButton = videojs.getComponent('Button');
|
|
* // Create a new instance of the component
|
|
* var myButton = new VjsButton(myPlayer);
|
|
* ```
|
|
*
|
|
* @return {Component} Component identified by name
|
|
* @mixes videojs
|
|
* @method getComponent
|
|
*/
|
|
videojs.getComponent = _component2['default'].getComponent;
|
|
|
|
/**
|
|
* Register a component so it can referred to by name
|
|
* Used when adding to other
|
|
* components, either through addChild
|
|
* `component.addChild('myComponent')`
|
|
* or through default children options
|
|
* `{ children: ['myComponent'] }`.
|
|
* ```js
|
|
* // Get a component to subclass
|
|
* var VjsButton = videojs.getComponent('Button');
|
|
* // Subclass the component (see 'extend' doc for more info)
|
|
* var MySpecialButton = videojs.extend(VjsButton, {});
|
|
* // Register the new component
|
|
* VjsButton.registerComponent('MySepcialButton', MySepcialButton);
|
|
* // (optionally) add the new component as a default player child
|
|
* myPlayer.addChild('MySepcialButton');
|
|
* ```
|
|
* NOTE: You could also just initialize the component before adding.
|
|
* `component.addChild(new MyComponent());`
|
|
*
|
|
* @param {String} The class name of the component
|
|
* @param {Component} The component class
|
|
* @return {Component} The newly registered component
|
|
* @mixes videojs
|
|
* @method registerComponent
|
|
*/
|
|
videojs.registerComponent = function (name, comp) {
|
|
if (_techTechJs2['default'].isTech(comp)) {
|
|
_utilsLogJs2['default'].warn('The ' + name + ' tech was registered as a component. It should instead be registered using videojs.registerTech(name, tech)');
|
|
}
|
|
|
|
_component2['default'].registerComponent.call(_component2['default'], name, comp);
|
|
};
|
|
|
|
/**
|
|
* Get a Tech class object by name
|
|
* ```js
|
|
* var Html5 = videojs.getTech('Html5');
|
|
* // Create a new instance of the component
|
|
* var html5 = new Html5(options);
|
|
* ```
|
|
*
|
|
* @return {Tech} Tech identified by name
|
|
* @mixes videojs
|
|
* @method getComponent
|
|
*/
|
|
videojs.getTech = _techTechJs2['default'].getTech;
|
|
|
|
/**
|
|
* Register a Tech so it can referred to by name.
|
|
* This is used in the tech order for the player.
|
|
*
|
|
* ```js
|
|
* // get the Html5 Tech
|
|
* var Html5 = videojs.getTech('Html5');
|
|
* var MyTech = videojs.extend(Html5, {});
|
|
* // Register the new Tech
|
|
* VjsButton.registerTech('Tech', MyTech);
|
|
* var player = videojs('myplayer', {
|
|
* techOrder: ['myTech', 'html5']
|
|
* });
|
|
* ```
|
|
*
|
|
* @param {String} The class name of the tech
|
|
* @param {Tech} The tech class
|
|
* @return {Tech} The newly registered Tech
|
|
* @mixes videojs
|
|
* @method registerTech
|
|
*/
|
|
videojs.registerTech = _techTechJs2['default'].registerTech;
|
|
|
|
/**
|
|
* A suite of browser and device tests
|
|
*
|
|
* @type {Object}
|
|
* @private
|
|
*/
|
|
videojs.browser = browser;
|
|
|
|
/**
|
|
* Whether or not the browser supports touch events. Included for backward
|
|
* compatibility with 4.x, but deprecated. Use `videojs.browser.TOUCH_ENABLED`
|
|
* instead going forward.
|
|
*
|
|
* @deprecated
|
|
* @type {Boolean}
|
|
*/
|
|
videojs.TOUCH_ENABLED = browser.TOUCH_ENABLED;
|
|
|
|
/**
|
|
* Subclass an existing class
|
|
* Mimics ES6 subclassing with the `extend` keyword
|
|
* ```js
|
|
* // Create a basic javascript 'class'
|
|
* function MyClass(name){
|
|
* // Set a property at initialization
|
|
* this.myName = name;
|
|
* }
|
|
* // Create an instance method
|
|
* MyClass.prototype.sayMyName = function(){
|
|
* alert(this.myName);
|
|
* };
|
|
* // Subclass the exisitng class and change the name
|
|
* // when initializing
|
|
* var MySubClass = videojs.extend(MyClass, {
|
|
* constructor: function(name) {
|
|
* // Call the super class constructor for the subclass
|
|
* MyClass.call(this, name)
|
|
* }
|
|
* });
|
|
* // Create an instance of the new sub class
|
|
* var myInstance = new MySubClass('John');
|
|
* myInstance.sayMyName(); // -> should alert "John"
|
|
* ```
|
|
*
|
|
* @param {Function} The Class to subclass
|
|
* @param {Object} An object including instace methods for the new class
|
|
* Optionally including a `constructor` function
|
|
* @return {Function} The newly created subclass
|
|
* @mixes videojs
|
|
* @method extend
|
|
*/
|
|
videojs.extend = _extendJs2['default'];
|
|
|
|
/**
|
|
* Merge two options objects recursively
|
|
* Performs a deep merge like lodash.merge but **only merges plain objects**
|
|
* (not arrays, elements, anything else)
|
|
* Other values will be copied directly from the second object.
|
|
* ```js
|
|
* var defaultOptions = {
|
|
* foo: true,
|
|
* bar: {
|
|
* a: true,
|
|
* b: [1,2,3]
|
|
* }
|
|
* };
|
|
* var newOptions = {
|
|
* foo: false,
|
|
* bar: {
|
|
* b: [4,5,6]
|
|
* }
|
|
* };
|
|
* var result = videojs.mergeOptions(defaultOptions, newOptions);
|
|
* // result.foo = false;
|
|
* // result.bar.a = true;
|
|
* // result.bar.b = [4,5,6];
|
|
* ```
|
|
*
|
|
* @param {Object} defaults The options object whose values will be overriden
|
|
* @param {Object} overrides The options object with values to override the first
|
|
* @param {Object} etc Any number of additional options objects
|
|
*
|
|
* @return {Object} a new object with the merged values
|
|
* @mixes videojs
|
|
* @method mergeOptions
|
|
*/
|
|
videojs.mergeOptions = _srcJsUtilsMergeOptionsJs2['default'];
|
|
|
|
/**
|
|
* Change the context (this) of a function
|
|
*
|
|
* videojs.bind(newContext, function(){
|
|
* this === newContext
|
|
* });
|
|
*
|
|
* NOTE: as of v5.0 we require an ES5 shim, so you should use the native
|
|
* `function(){}.bind(newContext);` instead of this.
|
|
*
|
|
* @param {*} context The object to bind as scope
|
|
* @param {Function} fn The function to be bound to a scope
|
|
* @param {Number=} uid An optional unique ID for the function to be set
|
|
* @return {Function}
|
|
*/
|
|
videojs.bind = Fn.bind;
|
|
|
|
/**
|
|
* Create a Video.js player plugin
|
|
* Plugins are only initialized when options for the plugin are included
|
|
* in the player options, or the plugin function on the player instance is
|
|
* called.
|
|
* **See the plugin guide in the docs for a more detailed example**
|
|
* ```js
|
|
* // Make a plugin that alerts when the player plays
|
|
* videojs.plugin('myPlugin', function(myPluginOptions) {
|
|
* myPluginOptions = myPluginOptions || {};
|
|
*
|
|
* var player = this;
|
|
* var alertText = myPluginOptions.text || 'Player is playing!'
|
|
*
|
|
* player.on('play', function(){
|
|
* alert(alertText);
|
|
* });
|
|
* });
|
|
* // USAGE EXAMPLES
|
|
* // EXAMPLE 1: New player with plugin options, call plugin immediately
|
|
* var player1 = videojs('idOne', {
|
|
* myPlugin: {
|
|
* text: 'Custom text!'
|
|
* }
|
|
* });
|
|
* // Click play
|
|
* // --> Should alert 'Custom text!'
|
|
* // EXAMPLE 3: New player, initialize plugin later
|
|
* var player3 = videojs('idThree');
|
|
* // Click play
|
|
* // --> NO ALERT
|
|
* // Click pause
|
|
* // Initialize plugin using the plugin function on the player instance
|
|
* player3.myPlugin({
|
|
* text: 'Plugin added later!'
|
|
* });
|
|
* // Click play
|
|
* // --> Should alert 'Plugin added later!'
|
|
* ```
|
|
*
|
|
* @param {String} name The plugin name
|
|
* @param {Function} fn The plugin function that will be called with options
|
|
* @mixes videojs
|
|
* @method plugin
|
|
*/
|
|
videojs.plugin = _pluginsJs2['default'];
|
|
|
|
/**
|
|
* Adding languages so that they're available to all players.
|
|
* ```js
|
|
* videojs.addLanguage('es', { 'Hello': 'Hola' });
|
|
* ```
|
|
*
|
|
* @param {String} code The language code or dictionary property
|
|
* @param {Object} data The data values to be translated
|
|
* @return {Object} The resulting language dictionary object
|
|
* @mixes videojs
|
|
* @method addLanguage
|
|
*/
|
|
videojs.addLanguage = function (code, data) {
|
|
var _merge;
|
|
|
|
code = ('' + code).toLowerCase();
|
|
return _lodashCompatObjectMerge2['default'](videojs.options.languages, (_merge = {}, _merge[code] = data, _merge))[code];
|
|
};
|
|
|
|
/**
|
|
* Log debug messages.
|
|
*
|
|
* @param {...Object} messages One or more messages to log
|
|
*/
|
|
videojs.log = _utilsLogJs2['default'];
|
|
|
|
/**
|
|
* Creates an emulated TimeRange object.
|
|
*
|
|
* @param {Number|Array} start Start time in seconds or an array of ranges
|
|
* @param {Number} end End time in seconds
|
|
* @return {Object} Fake TimeRange object
|
|
* @method createTimeRange
|
|
*/
|
|
videojs.createTimeRange = videojs.createTimeRanges = _utilsTimeRangesJs.createTimeRanges;
|
|
|
|
/**
|
|
* Format seconds as a time string, H:MM:SS or M:SS
|
|
* Supplying a guide (in seconds) will force a number of leading zeros
|
|
* to cover the length of the guide
|
|
*
|
|
* @param {Number} seconds Number of seconds to be turned into a string
|
|
* @param {Number} guide Number (in seconds) to model the string after
|
|
* @return {String} Time formatted as H:MM:SS or M:SS
|
|
* @method formatTime
|
|
*/
|
|
videojs.formatTime = _utilsFormatTimeJs2['default'];
|
|
|
|
/**
|
|
* Resolve and parse the elements of a URL
|
|
*
|
|
* @param {String} url The url to parse
|
|
* @return {Object} An object of url details
|
|
* @method parseUrl
|
|
*/
|
|
videojs.parseUrl = Url.parseUrl;
|
|
|
|
/**
|
|
* Returns whether the url passed is a cross domain request or not.
|
|
*
|
|
* @param {String} url The url to check
|
|
* @return {Boolean} Whether it is a cross domain request or not
|
|
* @method isCrossOrigin
|
|
*/
|
|
videojs.isCrossOrigin = Url.isCrossOrigin;
|
|
|
|
/**
|
|
* Event target class.
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
videojs.EventTarget = _eventTarget2['default'];
|
|
|
|
/**
|
|
* Add an event listener to element
|
|
* It stores the handler function in a separate cache object
|
|
* and adds a generic handler to the element's event,
|
|
* along with a unique id (guid) to the element.
|
|
*
|
|
* @param {Element|Object} elem Element or object to bind listeners to
|
|
* @param {String|Array} type Type of event to bind to.
|
|
* @param {Function} fn Event listener.
|
|
* @method on
|
|
*/
|
|
videojs.on = Events.on;
|
|
|
|
/**
|
|
* Trigger a listener only once for an event
|
|
*
|
|
* @param {Element|Object} elem Element or object to
|
|
* @param {String|Array} type Name/type of event
|
|
* @param {Function} fn Event handler function
|
|
* @method one
|
|
*/
|
|
videojs.one = Events.one;
|
|
|
|
/**
|
|
* Removes event listeners from an element
|
|
*
|
|
* @param {Element|Object} elem Object to remove listeners from
|
|
* @param {String|Array=} type Type of listener to remove. Don't include to remove all events from element.
|
|
* @param {Function} fn Specific listener to remove. Don't include to remove listeners for an event type.
|
|
* @method off
|
|
*/
|
|
videojs.off = Events.off;
|
|
|
|
/**
|
|
* Trigger an event for an element
|
|
*
|
|
* @param {Element|Object} elem Element to trigger an event on
|
|
* @param {Event|Object|String} event A string (the type) or an event object with a type attribute
|
|
* @param {Object} [hash] data hash to pass along with the event
|
|
* @return {Boolean=} Returned only if default was prevented
|
|
* @method trigger
|
|
*/
|
|
videojs.trigger = Events.trigger;
|
|
|
|
/**
|
|
* A cross-browser XMLHttpRequest wrapper. Here's a simple example:
|
|
*
|
|
* videojs.xhr({
|
|
* body: someJSONString,
|
|
* uri: "/foo",
|
|
* headers: {
|
|
* "Content-Type": "application/json"
|
|
* }
|
|
* }, function (err, resp, body) {
|
|
* // check resp.statusCode
|
|
* });
|
|
*
|
|
* Check out the [full
|
|
* documentation](https://github.com/Raynos/xhr/blob/v2.1.0/README.md)
|
|
* for more options.
|
|
*
|
|
* @param {Object} options settings for the request.
|
|
* @return {XMLHttpRequest|XDomainRequest} the request object.
|
|
* @see https://github.com/Raynos/xhr
|
|
*/
|
|
videojs.xhr = _xhr2['default'];
|
|
|
|
/**
|
|
* TextTrack class
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
videojs.TextTrack = _tracksTextTrackJs2['default'];
|
|
|
|
/**
|
|
* export the AudioTrack class so that source handlers can create
|
|
* AudioTracks and then add them to the players AudioTrackList
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
videojs.AudioTrack = _tracksAudioTrackJs2['default'];
|
|
|
|
/**
|
|
* export the VideoTrack class so that source handlers can create
|
|
* VideoTracks and then add them to the players VideoTrackList
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
videojs.VideoTrack = _tracksVideoTrackJs2['default'];
|
|
|
|
/**
|
|
* Determines, via duck typing, whether or not a value is a DOM element.
|
|
*
|
|
* @method isEl
|
|
* @param {Mixed} value
|
|
* @return {Boolean}
|
|
*/
|
|
videojs.isEl = Dom.isEl;
|
|
|
|
/**
|
|
* Determines, via duck typing, whether or not a value is a text node.
|
|
*
|
|
* @method isTextNode
|
|
* @param {Mixed} value
|
|
* @return {Boolean}
|
|
*/
|
|
videojs.isTextNode = Dom.isTextNode;
|
|
|
|
/**
|
|
* Creates an element and applies properties.
|
|
*
|
|
* @method createEl
|
|
* @param {String} [tagName='div'] Name of tag to be created.
|
|
* @param {Object} [properties={}] Element properties to be applied.
|
|
* @param {Object} [attributes={}] Element attributes to be applied.
|
|
* @return {Element}
|
|
*/
|
|
videojs.createEl = Dom.createEl;
|
|
|
|
/**
|
|
* Check if an element has a CSS class
|
|
*
|
|
* @method hasClass
|
|
* @param {Element} element Element to check
|
|
* @param {String} classToCheck Classname to check
|
|
*/
|
|
videojs.hasClass = Dom.hasElClass;
|
|
|
|
/**
|
|
* Add a CSS class name to an element
|
|
*
|
|
* @method addClass
|
|
* @param {Element} element Element to add class name to
|
|
* @param {String} classToAdd Classname to add
|
|
*/
|
|
videojs.addClass = Dom.addElClass;
|
|
|
|
/**
|
|
* Remove a CSS class name from an element
|
|
*
|
|
* @method removeClass
|
|
* @param {Element} element Element to remove from class name
|
|
* @param {String} classToRemove Classname to remove
|
|
*/
|
|
videojs.removeClass = Dom.removeElClass;
|
|
|
|
/**
|
|
* Adds or removes a CSS class name on an element depending on an optional
|
|
* condition or the presence/absence of the class name.
|
|
*
|
|
* @method toggleElClass
|
|
* @param {Element} element
|
|
* @param {String} classToToggle
|
|
* @param {Boolean|Function} [predicate]
|
|
* Can be a function that returns a Boolean. If `true`, the class
|
|
* will be added; if `false`, the class will be removed. If not
|
|
* given, the class will be added if not present and vice versa.
|
|
*/
|
|
videojs.toggleClass = Dom.toggleElClass;
|
|
|
|
/**
|
|
* Apply attributes to an HTML element.
|
|
*
|
|
* @method setAttributes
|
|
* @param {Element} el Target element.
|
|
* @param {Object=} attributes Element attributes to be applied.
|
|
*/
|
|
videojs.setAttributes = Dom.setElAttributes;
|
|
|
|
/**
|
|
* Get an element's attribute values, as defined on the HTML tag
|
|
* Attributes are not the same as properties. They're defined on the tag
|
|
* or with setAttribute (which shouldn't be used with HTML)
|
|
* This will return true or false for boolean attributes.
|
|
*
|
|
* @method getAttributes
|
|
* @param {Element} tag Element from which to get tag attributes
|
|
* @return {Object}
|
|
*/
|
|
videojs.getAttributes = Dom.getElAttributes;
|
|
|
|
/**
|
|
* Empties the contents of an element.
|
|
*
|
|
* @method emptyEl
|
|
* @param {Element} el
|
|
* @return {Element}
|
|
*/
|
|
videojs.emptyEl = Dom.emptyEl;
|
|
|
|
/**
|
|
* Normalizes and appends content to an element.
|
|
*
|
|
* The content for an element can be passed in multiple types and
|
|
* combinations, whose behavior is as follows:
|
|
*
|
|
* - String
|
|
* Normalized into a text node.
|
|
*
|
|
* - Element, TextNode
|
|
* Passed through.
|
|
*
|
|
* - Array
|
|
* A one-dimensional array of strings, elements, nodes, or functions (which
|
|
* return single strings, elements, or nodes).
|
|
*
|
|
* - Function
|
|
* If the sole argument, is expected to produce a string, element,
|
|
* node, or array.
|
|
*
|
|
* @method appendContent
|
|
* @param {Element} el
|
|
* @param {String|Element|TextNode|Array|Function} content
|
|
* @return {Element}
|
|
*/
|
|
videojs.appendContent = Dom.appendContent;
|
|
|
|
/**
|
|
* Normalizes and inserts content into an element; this is identical to
|
|
* `appendContent()`, except it empties the element first.
|
|
*
|
|
* The content for an element can be passed in multiple types and
|
|
* combinations, whose behavior is as follows:
|
|
*
|
|
* - String
|
|
* Normalized into a text node.
|
|
*
|
|
* - Element, TextNode
|
|
* Passed through.
|
|
*
|
|
* - Array
|
|
* A one-dimensional array of strings, elements, nodes, or functions (which
|
|
* return single strings, elements, or nodes).
|
|
*
|
|
* - Function
|
|
* If the sole argument, is expected to produce a string, element,
|
|
* node, or array.
|
|
*
|
|
* @method insertContent
|
|
* @param {Element} el
|
|
* @param {String|Element|TextNode|Array|Function} content
|
|
* @return {Element}
|
|
*/
|
|
videojs.insertContent = Dom.insertContent;
|
|
|
|
/*
|
|
* Custom Universal Module Definition (UMD)
|
|
*
|
|
* Video.js will never be a non-browser lib so we can simplify UMD a bunch and
|
|
* still support requirejs and browserify. This also needs to be closure
|
|
* compiler compatible, so string keys are used.
|
|
*/
|
|
if (typeof define === 'function' && define['amd']) {
|
|
define('videojs', [], function () {
|
|
return videojs;
|
|
});
|
|
|
|
// checking that module is an object too because of umdjs/umd#35
|
|
} else if (typeof exports === 'object' && typeof module === 'object') {
|
|
module['exports'] = videojs;
|
|
}
|
|
|
|
exports['default'] = videojs;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../../src/js/utils/merge-options.js":149,"./component":67,"./event-target":104,"./extend.js":105,"./player":113,"./plugins.js":114,"./setup":118,"./tech/flash.js":121,"./tech/html5.js":122,"./tech/tech.js":124,"./tracks/audio-track.js":126,"./tracks/text-track.js":134,"./tracks/video-track.js":139,"./utils/browser.js":140,"./utils/create-deprecation-proxy.js":142,"./utils/dom.js":143,"./utils/events.js":144,"./utils/fn.js":145,"./utils/format-time.js":146,"./utils/log.js":148,"./utils/stylesheet.js":150,"./utils/time-ranges.js":151,"./utils/url.js":153,"global/document":1,"global/window":2,"lodash-compat/object/merge":40,"object.assign":45,"xhr":56}]},{},[154])(154)
|
|
});
|
|
|
|
|
|
//# sourceMappingURL=video.js.map
|
|
/* vtt.js - v0.12.1 (https://github.com/mozilla/vtt.js) built on 08-07-2015 */
|
|
|
|
(function(root) {
|
|
var vttjs = root.vttjs = {};
|
|
var cueShim = vttjs.VTTCue;
|
|
var regionShim = vttjs.VTTRegion;
|
|
var oldVTTCue = root.VTTCue;
|
|
var oldVTTRegion = root.VTTRegion;
|
|
|
|
vttjs.shim = function() {
|
|
vttjs.VTTCue = cueShim;
|
|
vttjs.VTTRegion = regionShim;
|
|
};
|
|
|
|
vttjs.restore = function() {
|
|
vttjs.VTTCue = oldVTTCue;
|
|
vttjs.VTTRegion = oldVTTRegion;
|
|
};
|
|
}(this));
|
|
|
|
/**
|
|
* Copyright 2013 vtt.js Contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
(function(root, vttjs) {
|
|
|
|
var autoKeyword = "auto";
|
|
var directionSetting = {
|
|
"": true,
|
|
"lr": true,
|
|
"rl": true
|
|
};
|
|
var alignSetting = {
|
|
"start": true,
|
|
"middle": true,
|
|
"end": true,
|
|
"left": true,
|
|
"right": true
|
|
};
|
|
|
|
function findDirectionSetting(value) {
|
|
if (typeof value !== "string") {
|
|
return false;
|
|
}
|
|
var dir = directionSetting[value.toLowerCase()];
|
|
return dir ? value.toLowerCase() : false;
|
|
}
|
|
|
|
function findAlignSetting(value) {
|
|
if (typeof value !== "string") {
|
|
return false;
|
|
}
|
|
var align = alignSetting[value.toLowerCase()];
|
|
return align ? value.toLowerCase() : false;
|
|
}
|
|
|
|
function extend(obj) {
|
|
var i = 1;
|
|
for (; i < arguments.length; i++) {
|
|
var cobj = arguments[i];
|
|
for (var p in cobj) {
|
|
obj[p] = cobj[p];
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
function VTTCue(startTime, endTime, text) {
|
|
var cue = this;
|
|
var isIE8 = (/MSIE\s8\.0/).test(navigator.userAgent);
|
|
var baseObj = {};
|
|
|
|
if (isIE8) {
|
|
cue = document.createElement('custom');
|
|
} else {
|
|
baseObj.enumerable = true;
|
|
}
|
|
|
|
/**
|
|
* Shim implementation specific properties. These properties are not in
|
|
* the spec.
|
|
*/
|
|
|
|
// Lets us know when the VTTCue's data has changed in such a way that we need
|
|
// to recompute its display state. This lets us compute its display state
|
|
// lazily.
|
|
cue.hasBeenReset = false;
|
|
|
|
/**
|
|
* VTTCue and TextTrackCue properties
|
|
* http://dev.w3.org/html5/webvtt/#vttcue-interface
|
|
*/
|
|
|
|
var _id = "";
|
|
var _pauseOnExit = false;
|
|
var _startTime = startTime;
|
|
var _endTime = endTime;
|
|
var _text = text;
|
|
var _region = null;
|
|
var _vertical = "";
|
|
var _snapToLines = true;
|
|
var _line = "auto";
|
|
var _lineAlign = "start";
|
|
var _position = 50;
|
|
var _positionAlign = "middle";
|
|
var _size = 50;
|
|
var _align = "middle";
|
|
|
|
Object.defineProperty(cue,
|
|
"id", extend({}, baseObj, {
|
|
get: function() {
|
|
return _id;
|
|
},
|
|
set: function(value) {
|
|
_id = "" + value;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"pauseOnExit", extend({}, baseObj, {
|
|
get: function() {
|
|
return _pauseOnExit;
|
|
},
|
|
set: function(value) {
|
|
_pauseOnExit = !!value;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"startTime", extend({}, baseObj, {
|
|
get: function() {
|
|
return _startTime;
|
|
},
|
|
set: function(value) {
|
|
if (typeof value !== "number") {
|
|
throw new TypeError("Start time must be set to a number.");
|
|
}
|
|
_startTime = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"endTime", extend({}, baseObj, {
|
|
get: function() {
|
|
return _endTime;
|
|
},
|
|
set: function(value) {
|
|
if (typeof value !== "number") {
|
|
throw new TypeError("End time must be set to a number.");
|
|
}
|
|
_endTime = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"text", extend({}, baseObj, {
|
|
get: function() {
|
|
return _text;
|
|
},
|
|
set: function(value) {
|
|
_text = "" + value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"region", extend({}, baseObj, {
|
|
get: function() {
|
|
return _region;
|
|
},
|
|
set: function(value) {
|
|
_region = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"vertical", extend({}, baseObj, {
|
|
get: function() {
|
|
return _vertical;
|
|
},
|
|
set: function(value) {
|
|
var setting = findDirectionSetting(value);
|
|
// Have to check for false because the setting an be an empty string.
|
|
if (setting === false) {
|
|
throw new SyntaxError("An invalid or illegal string was specified.");
|
|
}
|
|
_vertical = setting;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"snapToLines", extend({}, baseObj, {
|
|
get: function() {
|
|
return _snapToLines;
|
|
},
|
|
set: function(value) {
|
|
_snapToLines = !!value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"line", extend({}, baseObj, {
|
|
get: function() {
|
|
return _line;
|
|
},
|
|
set: function(value) {
|
|
if (typeof value !== "number" && value !== autoKeyword) {
|
|
throw new SyntaxError("An invalid number or illegal string was specified.");
|
|
}
|
|
_line = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"lineAlign", extend({}, baseObj, {
|
|
get: function() {
|
|
return _lineAlign;
|
|
},
|
|
set: function(value) {
|
|
var setting = findAlignSetting(value);
|
|
if (!setting) {
|
|
throw new SyntaxError("An invalid or illegal string was specified.");
|
|
}
|
|
_lineAlign = setting;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"position", extend({}, baseObj, {
|
|
get: function() {
|
|
return _position;
|
|
},
|
|
set: function(value) {
|
|
if (value < 0 || value > 100) {
|
|
throw new Error("Position must be between 0 and 100.");
|
|
}
|
|
_position = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"positionAlign", extend({}, baseObj, {
|
|
get: function() {
|
|
return _positionAlign;
|
|
},
|
|
set: function(value) {
|
|
var setting = findAlignSetting(value);
|
|
if (!setting) {
|
|
throw new SyntaxError("An invalid or illegal string was specified.");
|
|
}
|
|
_positionAlign = setting;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"size", extend({}, baseObj, {
|
|
get: function() {
|
|
return _size;
|
|
},
|
|
set: function(value) {
|
|
if (value < 0 || value > 100) {
|
|
throw new Error("Size must be between 0 and 100.");
|
|
}
|
|
_size = value;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
Object.defineProperty(cue,
|
|
"align", extend({}, baseObj, {
|
|
get: function() {
|
|
return _align;
|
|
},
|
|
set: function(value) {
|
|
var setting = findAlignSetting(value);
|
|
if (!setting) {
|
|
throw new SyntaxError("An invalid or illegal string was specified.");
|
|
}
|
|
_align = setting;
|
|
this.hasBeenReset = true;
|
|
}
|
|
}));
|
|
|
|
/**
|
|
* Other <track> spec defined properties
|
|
*/
|
|
|
|
// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-display-state
|
|
cue.displayState = undefined;
|
|
|
|
if (isIE8) {
|
|
return cue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* VTTCue methods
|
|
*/
|
|
|
|
VTTCue.prototype.getCueAsHTML = function() {
|
|
// Assume WebVTT.convertCueToDOMTree is on the global.
|
|
return WebVTT.convertCueToDOMTree(window, this.text);
|
|
};
|
|
|
|
root.VTTCue = root.VTTCue || VTTCue;
|
|
vttjs.VTTCue = VTTCue;
|
|
}(this, (this.vttjs || {})));
|
|
|
|
/**
|
|
* Copyright 2013 vtt.js Contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
(function(root, vttjs) {
|
|
|
|
var scrollSetting = {
|
|
"": true,
|
|
"up": true
|
|
};
|
|
|
|
function findScrollSetting(value) {
|
|
if (typeof value !== "string") {
|
|
return false;
|
|
}
|
|
var scroll = scrollSetting[value.toLowerCase()];
|
|
return scroll ? value.toLowerCase() : false;
|
|
}
|
|
|
|
function isValidPercentValue(value) {
|
|
return typeof value === "number" && (value >= 0 && value <= 100);
|
|
}
|
|
|
|
// VTTRegion shim http://dev.w3.org/html5/webvtt/#vttregion-interface
|
|
function VTTRegion() {
|
|
var _width = 100;
|
|
var _lines = 3;
|
|
var _regionAnchorX = 0;
|
|
var _regionAnchorY = 100;
|
|
var _viewportAnchorX = 0;
|
|
var _viewportAnchorY = 100;
|
|
var _scroll = "";
|
|
|
|
Object.defineProperties(this, {
|
|
"width": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _width;
|
|
},
|
|
set: function(value) {
|
|
if (!isValidPercentValue(value)) {
|
|
throw new Error("Width must be between 0 and 100.");
|
|
}
|
|
_width = value;
|
|
}
|
|
},
|
|
"lines": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _lines;
|
|
},
|
|
set: function(value) {
|
|
if (typeof value !== "number") {
|
|
throw new TypeError("Lines must be set to a number.");
|
|
}
|
|
_lines = value;
|
|
}
|
|
},
|
|
"regionAnchorY": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _regionAnchorY;
|
|
},
|
|
set: function(value) {
|
|
if (!isValidPercentValue(value)) {
|
|
throw new Error("RegionAnchorX must be between 0 and 100.");
|
|
}
|
|
_regionAnchorY = value;
|
|
}
|
|
},
|
|
"regionAnchorX": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _regionAnchorX;
|
|
},
|
|
set: function(value) {
|
|
if(!isValidPercentValue(value)) {
|
|
throw new Error("RegionAnchorY must be between 0 and 100.");
|
|
}
|
|
_regionAnchorX = value;
|
|
}
|
|
},
|
|
"viewportAnchorY": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _viewportAnchorY;
|
|
},
|
|
set: function(value) {
|
|
if (!isValidPercentValue(value)) {
|
|
throw new Error("ViewportAnchorY must be between 0 and 100.");
|
|
}
|
|
_viewportAnchorY = value;
|
|
}
|
|
},
|
|
"viewportAnchorX": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _viewportAnchorX;
|
|
},
|
|
set: function(value) {
|
|
if (!isValidPercentValue(value)) {
|
|
throw new Error("ViewportAnchorX must be between 0 and 100.");
|
|
}
|
|
_viewportAnchorX = value;
|
|
}
|
|
},
|
|
"scroll": {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _scroll;
|
|
},
|
|
set: function(value) {
|
|
var setting = findScrollSetting(value);
|
|
// Have to check for false as an empty string is a legal value.
|
|
if (setting === false) {
|
|
throw new SyntaxError("An invalid or illegal string was specified.");
|
|
}
|
|
_scroll = setting;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
root.VTTRegion = root.VTTRegion || VTTRegion;
|
|
vttjs.VTTRegion = VTTRegion;
|
|
}(this, (this.vttjs || {})));
|
|
|
|
/**
|
|
* Copyright 2013 vtt.js Contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
|
|
|
|
(function(global) {
|
|
|
|
var _objCreate = Object.create || (function() {
|
|
function F() {}
|
|
return function(o) {
|
|
if (arguments.length !== 1) {
|
|
throw new Error('Object.create shim only accepts one parameter.');
|
|
}
|
|
F.prototype = o;
|
|
return new F();
|
|
};
|
|
})();
|
|
|
|
// Creates a new ParserError object from an errorData object. The errorData
|
|
// object should have default code and message properties. The default message
|
|
// property can be overriden by passing in a message parameter.
|
|
// See ParsingError.Errors below for acceptable errors.
|
|
function ParsingError(errorData, message) {
|
|
this.name = "ParsingError";
|
|
this.code = errorData.code;
|
|
this.message = message || errorData.message;
|
|
}
|
|
ParsingError.prototype = _objCreate(Error.prototype);
|
|
ParsingError.prototype.constructor = ParsingError;
|
|
|
|
// ParsingError metadata for acceptable ParsingErrors.
|
|
ParsingError.Errors = {
|
|
BadSignature: {
|
|
code: 0,
|
|
message: "Malformed WebVTT signature."
|
|
},
|
|
BadTimeStamp: {
|
|
code: 1,
|
|
message: "Malformed time stamp."
|
|
}
|
|
};
|
|
|
|
// Try to parse input as a time stamp.
|
|
function parseTimeStamp(input) {
|
|
|
|
function computeSeconds(h, m, s, f) {
|
|
return (h | 0) * 3600 + (m | 0) * 60 + (s | 0) + (f | 0) / 1000;
|
|
}
|
|
|
|
var m = input.match(/^(\d+):(\d{2})(:\d{2})?\.(\d{3})/);
|
|
if (!m) {
|
|
return null;
|
|
}
|
|
|
|
if (m[3]) {
|
|
// Timestamp takes the form of [hours]:[minutes]:[seconds].[milliseconds]
|
|
return computeSeconds(m[1], m[2], m[3].replace(":", ""), m[4]);
|
|
} else if (m[1] > 59) {
|
|
// Timestamp takes the form of [hours]:[minutes].[milliseconds]
|
|
// First position is hours as it's over 59.
|
|
return computeSeconds(m[1], m[2], 0, m[4]);
|
|
} else {
|
|
// Timestamp takes the form of [minutes]:[seconds].[milliseconds]
|
|
return computeSeconds(0, m[1], m[2], m[4]);
|
|
}
|
|
}
|
|
|
|
// A settings object holds key/value pairs and will ignore anything but the first
|
|
// assignment to a specific key.
|
|
function Settings() {
|
|
this.values = _objCreate(null);
|
|
}
|
|
|
|
Settings.prototype = {
|
|
// Only accept the first assignment to any key.
|
|
set: function(k, v) {
|
|
if (!this.get(k) && v !== "") {
|
|
this.values[k] = v;
|
|
}
|
|
},
|
|
// Return the value for a key, or a default value.
|
|
// If 'defaultKey' is passed then 'dflt' is assumed to be an object with
|
|
// a number of possible default values as properties where 'defaultKey' is
|
|
// the key of the property that will be chosen; otherwise it's assumed to be
|
|
// a single value.
|
|
get: function(k, dflt, defaultKey) {
|
|
if (defaultKey) {
|
|
return this.has(k) ? this.values[k] : dflt[defaultKey];
|
|
}
|
|
return this.has(k) ? this.values[k] : dflt;
|
|
},
|
|
// Check whether we have a value for a key.
|
|
has: function(k) {
|
|
return k in this.values;
|
|
},
|
|
// Accept a setting if its one of the given alternatives.
|
|
alt: function(k, v, a) {
|
|
for (var n = 0; n < a.length; ++n) {
|
|
if (v === a[n]) {
|
|
this.set(k, v);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
// Accept a setting if its a valid (signed) integer.
|
|
integer: function(k, v) {
|
|
if (/^-?\d+$/.test(v)) { // integer
|
|
this.set(k, parseInt(v, 10));
|
|
}
|
|
},
|
|
// Accept a setting if its a valid percentage.
|
|
percent: function(k, v) {
|
|
var m;
|
|
if ((m = v.match(/^([\d]{1,3})(\.[\d]*)?%$/))) {
|
|
v = parseFloat(v);
|
|
if (v >= 0 && v <= 100) {
|
|
this.set(k, v);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Helper function to parse input into groups separated by 'groupDelim', and
|
|
// interprete each group as a key/value pair separated by 'keyValueDelim'.
|
|
function parseOptions(input, callback, keyValueDelim, groupDelim) {
|
|
var groups = groupDelim ? input.split(groupDelim) : [input];
|
|
for (var i in groups) {
|
|
if (typeof groups[i] !== "string") {
|
|
continue;
|
|
}
|
|
var kv = groups[i].split(keyValueDelim);
|
|
if (kv.length !== 2) {
|
|
continue;
|
|
}
|
|
var k = kv[0];
|
|
var v = kv[1];
|
|
callback(k, v);
|
|
}
|
|
}
|
|
|
|
function parseCue(input, cue, regionList) {
|
|
// Remember the original input if we need to throw an error.
|
|
var oInput = input;
|
|
// 4.1 WebVTT timestamp
|
|
function consumeTimeStamp() {
|
|
var ts = parseTimeStamp(input);
|
|
if (ts === null) {
|
|
throw new ParsingError(ParsingError.Errors.BadTimeStamp,
|
|
"Malformed timestamp: " + oInput);
|
|
}
|
|
// Remove time stamp from input.
|
|
input = input.replace(/^[^\sa-zA-Z-]+/, "");
|
|
return ts;
|
|
}
|
|
|
|
// 4.4.2 WebVTT cue settings
|
|
function consumeCueSettings(input, cue) {
|
|
var settings = new Settings();
|
|
|
|
parseOptions(input, function (k, v) {
|
|
switch (k) {
|
|
case "region":
|
|
// Find the last region we parsed with the same region id.
|
|
for (var i = regionList.length - 1; i >= 0; i--) {
|
|
if (regionList[i].id === v) {
|
|
settings.set(k, regionList[i].region);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case "vertical":
|
|
settings.alt(k, v, ["rl", "lr"]);
|
|
break;
|
|
case "line":
|
|
var vals = v.split(","),
|
|
vals0 = vals[0];
|
|
settings.integer(k, vals0);
|
|
settings.percent(k, vals0) ? settings.set("snapToLines", false) : null;
|
|
settings.alt(k, vals0, ["auto"]);
|
|
if (vals.length === 2) {
|
|
settings.alt("lineAlign", vals[1], ["start", "middle", "end"]);
|
|
}
|
|
break;
|
|
case "position":
|
|
vals = v.split(",");
|
|
settings.percent(k, vals[0]);
|
|
if (vals.length === 2) {
|
|
settings.alt("positionAlign", vals[1], ["start", "middle", "end"]);
|
|
}
|
|
break;
|
|
case "size":
|
|
settings.percent(k, v);
|
|
break;
|
|
case "align":
|
|
settings.alt(k, v, ["start", "middle", "end", "left", "right"]);
|
|
break;
|
|
}
|
|
}, /:/, /\s/);
|
|
|
|
// Apply default values for any missing fields.
|
|
cue.region = settings.get("region", null);
|
|
cue.vertical = settings.get("vertical", "");
|
|
cue.line = settings.get("line", "auto");
|
|
cue.lineAlign = settings.get("lineAlign", "start");
|
|
cue.snapToLines = settings.get("snapToLines", true);
|
|
cue.size = settings.get("size", 100);
|
|
cue.align = settings.get("align", "middle");
|
|
cue.position = settings.get("position", {
|
|
start: 0,
|
|
left: 0,
|
|
middle: 50,
|
|
end: 100,
|
|
right: 100
|
|
}, cue.align);
|
|
cue.positionAlign = settings.get("positionAlign", {
|
|
start: "start",
|
|
left: "start",
|
|
middle: "middle",
|
|
end: "end",
|
|
right: "end"
|
|
}, cue.align);
|
|
}
|
|
|
|
function skipWhitespace() {
|
|
input = input.replace(/^\s+/, "");
|
|
}
|
|
|
|
// 4.1 WebVTT cue timings.
|
|
skipWhitespace();
|
|
cue.startTime = consumeTimeStamp(); // (1) collect cue start time
|
|
skipWhitespace();
|
|
if (input.substr(0, 3) !== "-->") { // (3) next characters must match "-->"
|
|
throw new ParsingError(ParsingError.Errors.BadTimeStamp,
|
|
"Malformed time stamp (time stamps must be separated by '-->'): " +
|
|
oInput);
|
|
}
|
|
input = input.substr(3);
|
|
skipWhitespace();
|
|
cue.endTime = consumeTimeStamp(); // (5) collect cue end time
|
|
|
|
// 4.1 WebVTT cue settings list.
|
|
skipWhitespace();
|
|
consumeCueSettings(input, cue);
|
|
}
|
|
|
|
var ESCAPE = {
|
|
"&": "&",
|
|
"<": "<",
|
|
">": ">",
|
|
"‎": "\u200e",
|
|
"‏": "\u200f",
|
|
" ": "\u00a0"
|
|
};
|
|
|
|
var TAG_NAME = {
|
|
c: "span",
|
|
i: "i",
|
|
b: "b",
|
|
u: "u",
|
|
ruby: "ruby",
|
|
rt: "rt",
|
|
v: "span",
|
|
lang: "span"
|
|
};
|
|
|
|
var TAG_ANNOTATION = {
|
|
v: "title",
|
|
lang: "lang"
|
|
};
|
|
|
|
var NEEDS_PARENT = {
|
|
rt: "ruby"
|
|
};
|
|
|
|
// Parse content into a document fragment.
|
|
function parseContent(window, input) {
|
|
function nextToken() {
|
|
// Check for end-of-string.
|
|
if (!input) {
|
|
return null;
|
|
}
|
|
|
|
// Consume 'n' characters from the input.
|
|
function consume(result) {
|
|
input = input.substr(result.length);
|
|
return result;
|
|
}
|
|
|
|
var m = input.match(/^([^<]*)(<[^>]+>?)?/);
|
|
// If there is some text before the next tag, return it, otherwise return
|
|
// the tag.
|
|
return consume(m[1] ? m[1] : m[2]);
|
|
}
|
|
|
|
// Unescape a string 's'.
|
|
function unescape1(e) {
|
|
return ESCAPE[e];
|
|
}
|
|
function unescape(s) {
|
|
while ((m = s.match(/&(amp|lt|gt|lrm|rlm|nbsp);/))) {
|
|
s = s.replace(m[0], unescape1);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
function shouldAdd(current, element) {
|
|
return !NEEDS_PARENT[element.localName] ||
|
|
NEEDS_PARENT[element.localName] === current.localName;
|
|
}
|
|
|
|
// Create an element for this tag.
|
|
function createElement(type, annotation) {
|
|
var tagName = TAG_NAME[type];
|
|
if (!tagName) {
|
|
return null;
|
|
}
|
|
var element = window.document.createElement(tagName);
|
|
element.localName = tagName;
|
|
var name = TAG_ANNOTATION[type];
|
|
if (name && annotation) {
|
|
element[name] = annotation.trim();
|
|
}
|
|
return element;
|
|
}
|
|
|
|
var rootDiv = window.document.createElement("div"),
|
|
current = rootDiv,
|
|
t,
|
|
tagStack = [];
|
|
|
|
while ((t = nextToken()) !== null) {
|
|
if (t[0] === '<') {
|
|
if (t[1] === "/") {
|
|
// If the closing tag matches, move back up to the parent node.
|
|
if (tagStack.length &&
|
|
tagStack[tagStack.length - 1] === t.substr(2).replace(">", "")) {
|
|
tagStack.pop();
|
|
current = current.parentNode;
|
|
}
|
|
// Otherwise just ignore the end tag.
|
|
continue;
|
|
}
|
|
var ts = parseTimeStamp(t.substr(1, t.length - 2));
|
|
var node;
|
|
if (ts) {
|
|
// Timestamps are lead nodes as well.
|
|
node = window.document.createProcessingInstruction("timestamp", ts);
|
|
current.appendChild(node);
|
|
continue;
|
|
}
|
|
var m = t.match(/^<([^.\s/0-9>]+)(\.[^\s\\>]+)?([^>\\]+)?(\\?)>?$/);
|
|
// If we can't parse the tag, skip to the next tag.
|
|
if (!m) {
|
|
continue;
|
|
}
|
|
// Try to construct an element, and ignore the tag if we couldn't.
|
|
node = createElement(m[1], m[3]);
|
|
if (!node) {
|
|
continue;
|
|
}
|
|
// Determine if the tag should be added based on the context of where it
|
|
// is placed in the cuetext.
|
|
if (!shouldAdd(current, node)) {
|
|
continue;
|
|
}
|
|
// Set the class list (as a list of classes, separated by space).
|
|
if (m[2]) {
|
|
node.className = m[2].substr(1).replace('.', ' ');
|
|
}
|
|
// Append the node to the current node, and enter the scope of the new
|
|
// node.
|
|
tagStack.push(m[1]);
|
|
current.appendChild(node);
|
|
current = node;
|
|
continue;
|
|
}
|
|
|
|
// Text nodes are leaf nodes.
|
|
current.appendChild(window.document.createTextNode(unescape(t)));
|
|
}
|
|
|
|
return rootDiv;
|
|
}
|
|
|
|
// This is a list of all the Unicode characters that have a strong
|
|
// right-to-left category. What this means is that these characters are
|
|
// written right-to-left for sure. It was generated by pulling all the strong
|
|
// right-to-left characters out of the Unicode data table. That table can
|
|
// found at: http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
|
|
var strongRTLChars = [0x05BE, 0x05C0, 0x05C3, 0x05C6, 0x05D0, 0x05D1,
|
|
0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA,
|
|
0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF, 0x05E0, 0x05E1, 0x05E2, 0x05E3,
|
|
0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x05F0, 0x05F1,
|
|
0x05F2, 0x05F3, 0x05F4, 0x0608, 0x060B, 0x060D, 0x061B, 0x061E, 0x061F,
|
|
0x0620, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628,
|
|
0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F, 0x0630, 0x0631,
|
|
0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x063A,
|
|
0x063B, 0x063C, 0x063D, 0x063E, 0x063F, 0x0640, 0x0641, 0x0642, 0x0643,
|
|
0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A, 0x066D, 0x066E,
|
|
0x066F, 0x0671, 0x0672, 0x0673, 0x0674, 0x0675, 0x0676, 0x0677, 0x0678,
|
|
0x0679, 0x067A, 0x067B, 0x067C, 0x067D, 0x067E, 0x067F, 0x0680, 0x0681,
|
|
0x0682, 0x0683, 0x0684, 0x0685, 0x0686, 0x0687, 0x0688, 0x0689, 0x068A,
|
|
0x068B, 0x068C, 0x068D, 0x068E, 0x068F, 0x0690, 0x0691, 0x0692, 0x0693,
|
|
0x0694, 0x0695, 0x0696, 0x0697, 0x0698, 0x0699, 0x069A, 0x069B, 0x069C,
|
|
0x069D, 0x069E, 0x069F, 0x06A0, 0x06A1, 0x06A2, 0x06A3, 0x06A4, 0x06A5,
|
|
0x06A6, 0x06A7, 0x06A8, 0x06A9, 0x06AA, 0x06AB, 0x06AC, 0x06AD, 0x06AE,
|
|
0x06AF, 0x06B0, 0x06B1, 0x06B2, 0x06B3, 0x06B4, 0x06B5, 0x06B6, 0x06B7,
|
|
0x06B8, 0x06B9, 0x06BA, 0x06BB, 0x06BC, 0x06BD, 0x06BE, 0x06BF, 0x06C0,
|
|
0x06C1, 0x06C2, 0x06C3, 0x06C4, 0x06C5, 0x06C6, 0x06C7, 0x06C8, 0x06C9,
|
|
0x06CA, 0x06CB, 0x06CC, 0x06CD, 0x06CE, 0x06CF, 0x06D0, 0x06D1, 0x06D2,
|
|
0x06D3, 0x06D4, 0x06D5, 0x06E5, 0x06E6, 0x06EE, 0x06EF, 0x06FA, 0x06FB,
|
|
0x06FC, 0x06FD, 0x06FE, 0x06FF, 0x0700, 0x0701, 0x0702, 0x0703, 0x0704,
|
|
0x0705, 0x0706, 0x0707, 0x0708, 0x0709, 0x070A, 0x070B, 0x070C, 0x070D,
|
|
0x070F, 0x0710, 0x0712, 0x0713, 0x0714, 0x0715, 0x0716, 0x0717, 0x0718,
|
|
0x0719, 0x071A, 0x071B, 0x071C, 0x071D, 0x071E, 0x071F, 0x0720, 0x0721,
|
|
0x0722, 0x0723, 0x0724, 0x0725, 0x0726, 0x0727, 0x0728, 0x0729, 0x072A,
|
|
0x072B, 0x072C, 0x072D, 0x072E, 0x072F, 0x074D, 0x074E, 0x074F, 0x0750,
|
|
0x0751, 0x0752, 0x0753, 0x0754, 0x0755, 0x0756, 0x0757, 0x0758, 0x0759,
|
|
0x075A, 0x075B, 0x075C, 0x075D, 0x075E, 0x075F, 0x0760, 0x0761, 0x0762,
|
|
0x0763, 0x0764, 0x0765, 0x0766, 0x0767, 0x0768, 0x0769, 0x076A, 0x076B,
|
|
0x076C, 0x076D, 0x076E, 0x076F, 0x0770, 0x0771, 0x0772, 0x0773, 0x0774,
|
|
0x0775, 0x0776, 0x0777, 0x0778, 0x0779, 0x077A, 0x077B, 0x077C, 0x077D,
|
|
0x077E, 0x077F, 0x0780, 0x0781, 0x0782, 0x0783, 0x0784, 0x0785, 0x0786,
|
|
0x0787, 0x0788, 0x0789, 0x078A, 0x078B, 0x078C, 0x078D, 0x078E, 0x078F,
|
|
0x0790, 0x0791, 0x0792, 0x0793, 0x0794, 0x0795, 0x0796, 0x0797, 0x0798,
|
|
0x0799, 0x079A, 0x079B, 0x079C, 0x079D, 0x079E, 0x079F, 0x07A0, 0x07A1,
|
|
0x07A2, 0x07A3, 0x07A4, 0x07A5, 0x07B1, 0x07C0, 0x07C1, 0x07C2, 0x07C3,
|
|
0x07C4, 0x07C5, 0x07C6, 0x07C7, 0x07C8, 0x07C9, 0x07CA, 0x07CB, 0x07CC,
|
|
0x07CD, 0x07CE, 0x07CF, 0x07D0, 0x07D1, 0x07D2, 0x07D3, 0x07D4, 0x07D5,
|
|
0x07D6, 0x07D7, 0x07D8, 0x07D9, 0x07DA, 0x07DB, 0x07DC, 0x07DD, 0x07DE,
|
|
0x07DF, 0x07E0, 0x07E1, 0x07E2, 0x07E3, 0x07E4, 0x07E5, 0x07E6, 0x07E7,
|
|
0x07E8, 0x07E9, 0x07EA, 0x07F4, 0x07F5, 0x07FA, 0x0800, 0x0801, 0x0802,
|
|
0x0803, 0x0804, 0x0805, 0x0806, 0x0807, 0x0808, 0x0809, 0x080A, 0x080B,
|
|
0x080C, 0x080D, 0x080E, 0x080F, 0x0810, 0x0811, 0x0812, 0x0813, 0x0814,
|
|
0x0815, 0x081A, 0x0824, 0x0828, 0x0830, 0x0831, 0x0832, 0x0833, 0x0834,
|
|
0x0835, 0x0836, 0x0837, 0x0838, 0x0839, 0x083A, 0x083B, 0x083C, 0x083D,
|
|
0x083E, 0x0840, 0x0841, 0x0842, 0x0843, 0x0844, 0x0845, 0x0846, 0x0847,
|
|
0x0848, 0x0849, 0x084A, 0x084B, 0x084C, 0x084D, 0x084E, 0x084F, 0x0850,
|
|
0x0851, 0x0852, 0x0853, 0x0854, 0x0855, 0x0856, 0x0857, 0x0858, 0x085E,
|
|
0x08A0, 0x08A2, 0x08A3, 0x08A4, 0x08A5, 0x08A6, 0x08A7, 0x08A8, 0x08A9,
|
|
0x08AA, 0x08AB, 0x08AC, 0x200F, 0xFB1D, 0xFB1F, 0xFB20, 0xFB21, 0xFB22,
|
|
0xFB23, 0xFB24, 0xFB25, 0xFB26, 0xFB27, 0xFB28, 0xFB2A, 0xFB2B, 0xFB2C,
|
|
0xFB2D, 0xFB2E, 0xFB2F, 0xFB30, 0xFB31, 0xFB32, 0xFB33, 0xFB34, 0xFB35,
|
|
0xFB36, 0xFB38, 0xFB39, 0xFB3A, 0xFB3B, 0xFB3C, 0xFB3E, 0xFB40, 0xFB41,
|
|
0xFB43, 0xFB44, 0xFB46, 0xFB47, 0xFB48, 0xFB49, 0xFB4A, 0xFB4B, 0xFB4C,
|
|
0xFB4D, 0xFB4E, 0xFB4F, 0xFB50, 0xFB51, 0xFB52, 0xFB53, 0xFB54, 0xFB55,
|
|
0xFB56, 0xFB57, 0xFB58, 0xFB59, 0xFB5A, 0xFB5B, 0xFB5C, 0xFB5D, 0xFB5E,
|
|
0xFB5F, 0xFB60, 0xFB61, 0xFB62, 0xFB63, 0xFB64, 0xFB65, 0xFB66, 0xFB67,
|
|
0xFB68, 0xFB69, 0xFB6A, 0xFB6B, 0xFB6C, 0xFB6D, 0xFB6E, 0xFB6F, 0xFB70,
|
|
0xFB71, 0xFB72, 0xFB73, 0xFB74, 0xFB75, 0xFB76, 0xFB77, 0xFB78, 0xFB79,
|
|
0xFB7A, 0xFB7B, 0xFB7C, 0xFB7D, 0xFB7E, 0xFB7F, 0xFB80, 0xFB81, 0xFB82,
|
|
0xFB83, 0xFB84, 0xFB85, 0xFB86, 0xFB87, 0xFB88, 0xFB89, 0xFB8A, 0xFB8B,
|
|
0xFB8C, 0xFB8D, 0xFB8E, 0xFB8F, 0xFB90, 0xFB91, 0xFB92, 0xFB93, 0xFB94,
|
|
0xFB95, 0xFB96, 0xFB97, 0xFB98, 0xFB99, 0xFB9A, 0xFB9B, 0xFB9C, 0xFB9D,
|
|
0xFB9E, 0xFB9F, 0xFBA0, 0xFBA1, 0xFBA2, 0xFBA3, 0xFBA4, 0xFBA5, 0xFBA6,
|
|
0xFBA7, 0xFBA8, 0xFBA9, 0xFBAA, 0xFBAB, 0xFBAC, 0xFBAD, 0xFBAE, 0xFBAF,
|
|
0xFBB0, 0xFBB1, 0xFBB2, 0xFBB3, 0xFBB4, 0xFBB5, 0xFBB6, 0xFBB7, 0xFBB8,
|
|
0xFBB9, 0xFBBA, 0xFBBB, 0xFBBC, 0xFBBD, 0xFBBE, 0xFBBF, 0xFBC0, 0xFBC1,
|
|
0xFBD3, 0xFBD4, 0xFBD5, 0xFBD6, 0xFBD7, 0xFBD8, 0xFBD9, 0xFBDA, 0xFBDB,
|
|
0xFBDC, 0xFBDD, 0xFBDE, 0xFBDF, 0xFBE0, 0xFBE1, 0xFBE2, 0xFBE3, 0xFBE4,
|
|
0xFBE5, 0xFBE6, 0xFBE7, 0xFBE8, 0xFBE9, 0xFBEA, 0xFBEB, 0xFBEC, 0xFBED,
|
|
0xFBEE, 0xFBEF, 0xFBF0, 0xFBF1, 0xFBF2, 0xFBF3, 0xFBF4, 0xFBF5, 0xFBF6,
|
|
0xFBF7, 0xFBF8, 0xFBF9, 0xFBFA, 0xFBFB, 0xFBFC, 0xFBFD, 0xFBFE, 0xFBFF,
|
|
0xFC00, 0xFC01, 0xFC02, 0xFC03, 0xFC04, 0xFC05, 0xFC06, 0xFC07, 0xFC08,
|
|
0xFC09, 0xFC0A, 0xFC0B, 0xFC0C, 0xFC0D, 0xFC0E, 0xFC0F, 0xFC10, 0xFC11,
|
|
0xFC12, 0xFC13, 0xFC14, 0xFC15, 0xFC16, 0xFC17, 0xFC18, 0xFC19, 0xFC1A,
|
|
0xFC1B, 0xFC1C, 0xFC1D, 0xFC1E, 0xFC1F, 0xFC20, 0xFC21, 0xFC22, 0xFC23,
|
|
0xFC24, 0xFC25, 0xFC26, 0xFC27, 0xFC28, 0xFC29, 0xFC2A, 0xFC2B, 0xFC2C,
|
|
0xFC2D, 0xFC2E, 0xFC2F, 0xFC30, 0xFC31, 0xFC32, 0xFC33, 0xFC34, 0xFC35,
|
|
0xFC36, 0xFC37, 0xFC38, 0xFC39, 0xFC3A, 0xFC3B, 0xFC3C, 0xFC3D, 0xFC3E,
|
|
0xFC3F, 0xFC40, 0xFC41, 0xFC42, 0xFC43, 0xFC44, 0xFC45, 0xFC46, 0xFC47,
|
|
0xFC48, 0xFC49, 0xFC4A, 0xFC4B, 0xFC4C, 0xFC4D, 0xFC4E, 0xFC4F, 0xFC50,
|
|
0xFC51, 0xFC52, 0xFC53, 0xFC54, 0xFC55, 0xFC56, 0xFC57, 0xFC58, 0xFC59,
|
|
0xFC5A, 0xFC5B, 0xFC5C, 0xFC5D, 0xFC5E, 0xFC5F, 0xFC60, 0xFC61, 0xFC62,
|
|
0xFC63, 0xFC64, 0xFC65, 0xFC66, 0xFC67, 0xFC68, 0xFC69, 0xFC6A, 0xFC6B,
|
|
0xFC6C, 0xFC6D, 0xFC6E, 0xFC6F, 0xFC70, 0xFC71, 0xFC72, 0xFC73, 0xFC74,
|
|
0xFC75, 0xFC76, 0xFC77, 0xFC78, 0xFC79, 0xFC7A, 0xFC7B, 0xFC7C, 0xFC7D,
|
|
0xFC7E, 0xFC7F, 0xFC80, 0xFC81, 0xFC82, 0xFC83, 0xFC84, 0xFC85, 0xFC86,
|
|
0xFC87, 0xFC88, 0xFC89, 0xFC8A, 0xFC8B, 0xFC8C, 0xFC8D, 0xFC8E, 0xFC8F,
|
|
0xFC90, 0xFC91, 0xFC92, 0xFC93, 0xFC94, 0xFC95, 0xFC96, 0xFC97, 0xFC98,
|
|
0xFC99, 0xFC9A, 0xFC9B, 0xFC9C, 0xFC9D, 0xFC9E, 0xFC9F, 0xFCA0, 0xFCA1,
|
|
0xFCA2, 0xFCA3, 0xFCA4, 0xFCA5, 0xFCA6, 0xFCA7, 0xFCA8, 0xFCA9, 0xFCAA,
|
|
0xFCAB, 0xFCAC, 0xFCAD, 0xFCAE, 0xFCAF, 0xFCB0, 0xFCB1, 0xFCB2, 0xFCB3,
|
|
0xFCB4, 0xFCB5, 0xFCB6, 0xFCB7, 0xFCB8, 0xFCB9, 0xFCBA, 0xFCBB, 0xFCBC,
|
|
0xFCBD, 0xFCBE, 0xFCBF, 0xFCC0, 0xFCC1, 0xFCC2, 0xFCC3, 0xFCC4, 0xFCC5,
|
|
0xFCC6, 0xFCC7, 0xFCC8, 0xFCC9, 0xFCCA, 0xFCCB, 0xFCCC, 0xFCCD, 0xFCCE,
|
|
0xFCCF, 0xFCD0, 0xFCD1, 0xFCD2, 0xFCD3, 0xFCD4, 0xFCD5, 0xFCD6, 0xFCD7,
|
|
0xFCD8, 0xFCD9, 0xFCDA, 0xFCDB, 0xFCDC, 0xFCDD, 0xFCDE, 0xFCDF, 0xFCE0,
|
|
0xFCE1, 0xFCE2, 0xFCE3, 0xFCE4, 0xFCE5, 0xFCE6, 0xFCE7, 0xFCE8, 0xFCE9,
|
|
0xFCEA, 0xFCEB, 0xFCEC, 0xFCED, 0xFCEE, 0xFCEF, 0xFCF0, 0xFCF1, 0xFCF2,
|
|
0xFCF3, 0xFCF4, 0xFCF5, 0xFCF6, 0xFCF7, 0xFCF8, 0xFCF9, 0xFCFA, 0xFCFB,
|
|
0xFCFC, 0xFCFD, 0xFCFE, 0xFCFF, 0xFD00, 0xFD01, 0xFD02, 0xFD03, 0xFD04,
|
|
0xFD05, 0xFD06, 0xFD07, 0xFD08, 0xFD09, 0xFD0A, 0xFD0B, 0xFD0C, 0xFD0D,
|
|
0xFD0E, 0xFD0F, 0xFD10, 0xFD11, 0xFD12, 0xFD13, 0xFD14, 0xFD15, 0xFD16,
|
|
0xFD17, 0xFD18, 0xFD19, 0xFD1A, 0xFD1B, 0xFD1C, 0xFD1D, 0xFD1E, 0xFD1F,
|
|
0xFD20, 0xFD21, 0xFD22, 0xFD23, 0xFD24, 0xFD25, 0xFD26, 0xFD27, 0xFD28,
|
|
0xFD29, 0xFD2A, 0xFD2B, 0xFD2C, 0xFD2D, 0xFD2E, 0xFD2F, 0xFD30, 0xFD31,
|
|
0xFD32, 0xFD33, 0xFD34, 0xFD35, 0xFD36, 0xFD37, 0xFD38, 0xFD39, 0xFD3A,
|
|
0xFD3B, 0xFD3C, 0xFD3D, 0xFD50, 0xFD51, 0xFD52, 0xFD53, 0xFD54, 0xFD55,
|
|
0xFD56, 0xFD57, 0xFD58, 0xFD59, 0xFD5A, 0xFD5B, 0xFD5C, 0xFD5D, 0xFD5E,
|
|
0xFD5F, 0xFD60, 0xFD61, 0xFD62, 0xFD63, 0xFD64, 0xFD65, 0xFD66, 0xFD67,
|
|
0xFD68, 0xFD69, 0xFD6A, 0xFD6B, 0xFD6C, 0xFD6D, 0xFD6E, 0xFD6F, 0xFD70,
|
|
0xFD71, 0xFD72, 0xFD73, 0xFD74, 0xFD75, 0xFD76, 0xFD77, 0xFD78, 0xFD79,
|
|
0xFD7A, 0xFD7B, 0xFD7C, 0xFD7D, 0xFD7E, 0xFD7F, 0xFD80, 0xFD81, 0xFD82,
|
|
0xFD83, 0xFD84, 0xFD85, 0xFD86, 0xFD87, 0xFD88, 0xFD89, 0xFD8A, 0xFD8B,
|
|
0xFD8C, 0xFD8D, 0xFD8E, 0xFD8F, 0xFD92, 0xFD93, 0xFD94, 0xFD95, 0xFD96,
|
|
0xFD97, 0xFD98, 0xFD99, 0xFD9A, 0xFD9B, 0xFD9C, 0xFD9D, 0xFD9E, 0xFD9F,
|
|
0xFDA0, 0xFDA1, 0xFDA2, 0xFDA3, 0xFDA4, 0xFDA5, 0xFDA6, 0xFDA7, 0xFDA8,
|
|
0xFDA9, 0xFDAA, 0xFDAB, 0xFDAC, 0xFDAD, 0xFDAE, 0xFDAF, 0xFDB0, 0xFDB1,
|
|
0xFDB2, 0xFDB3, 0xFDB4, 0xFDB5, 0xFDB6, 0xFDB7, 0xFDB8, 0xFDB9, 0xFDBA,
|
|
0xFDBB, 0xFDBC, 0xFDBD, 0xFDBE, 0xFDBF, 0xFDC0, 0xFDC1, 0xFDC2, 0xFDC3,
|
|
0xFDC4, 0xFDC5, 0xFDC6, 0xFDC7, 0xFDF0, 0xFDF1, 0xFDF2, 0xFDF3, 0xFDF4,
|
|
0xFDF5, 0xFDF6, 0xFDF7, 0xFDF8, 0xFDF9, 0xFDFA, 0xFDFB, 0xFDFC, 0xFE70,
|
|
0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE76, 0xFE77, 0xFE78, 0xFE79, 0xFE7A,
|
|
0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE7F, 0xFE80, 0xFE81, 0xFE82, 0xFE83,
|
|
0xFE84, 0xFE85, 0xFE86, 0xFE87, 0xFE88, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C,
|
|
0xFE8D, 0xFE8E, 0xFE8F, 0xFE90, 0xFE91, 0xFE92, 0xFE93, 0xFE94, 0xFE95,
|
|
0xFE96, 0xFE97, 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E,
|
|
0xFE9F, 0xFEA0, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, 0xFEA5, 0xFEA6, 0xFEA7,
|
|
0xFEA8, 0xFEA9, 0xFEAA, 0xFEAB, 0xFEAC, 0xFEAD, 0xFEAE, 0xFEAF, 0xFEB0,
|
|
0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, 0xFEB5, 0xFEB6, 0xFEB7, 0xFEB8, 0xFEB9,
|
|
0xFEBA, 0xFEBB, 0xFEBC, 0xFEBD, 0xFEBE, 0xFEBF, 0xFEC0, 0xFEC1, 0xFEC2,
|
|
0xFEC3, 0xFEC4, 0xFEC5, 0xFEC6, 0xFEC7, 0xFEC8, 0xFEC9, 0xFECA, 0xFECB,
|
|
0xFECC, 0xFECD, 0xFECE, 0xFECF, 0xFED0, 0xFED1, 0xFED2, 0xFED3, 0xFED4,
|
|
0xFED5, 0xFED6, 0xFED7, 0xFED8, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, 0xFEDD,
|
|
0xFEDE, 0xFEDF, 0xFEE0, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, 0xFEE5, 0xFEE6,
|
|
0xFEE7, 0xFEE8, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, 0xFEED, 0xFEEE, 0xFEEF,
|
|
0xFEF0, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, 0xFEF5, 0xFEF6, 0xFEF7, 0xFEF8,
|
|
0xFEF9, 0xFEFA, 0xFEFB, 0xFEFC, 0x10800, 0x10801, 0x10802, 0x10803,
|
|
0x10804, 0x10805, 0x10808, 0x1080A, 0x1080B, 0x1080C, 0x1080D, 0x1080E,
|
|
0x1080F, 0x10810, 0x10811, 0x10812, 0x10813, 0x10814, 0x10815, 0x10816,
|
|
0x10817, 0x10818, 0x10819, 0x1081A, 0x1081B, 0x1081C, 0x1081D, 0x1081E,
|
|
0x1081F, 0x10820, 0x10821, 0x10822, 0x10823, 0x10824, 0x10825, 0x10826,
|
|
0x10827, 0x10828, 0x10829, 0x1082A, 0x1082B, 0x1082C, 0x1082D, 0x1082E,
|
|
0x1082F, 0x10830, 0x10831, 0x10832, 0x10833, 0x10834, 0x10835, 0x10837,
|
|
0x10838, 0x1083C, 0x1083F, 0x10840, 0x10841, 0x10842, 0x10843, 0x10844,
|
|
0x10845, 0x10846, 0x10847, 0x10848, 0x10849, 0x1084A, 0x1084B, 0x1084C,
|
|
0x1084D, 0x1084E, 0x1084F, 0x10850, 0x10851, 0x10852, 0x10853, 0x10854,
|
|
0x10855, 0x10857, 0x10858, 0x10859, 0x1085A, 0x1085B, 0x1085C, 0x1085D,
|
|
0x1085E, 0x1085F, 0x10900, 0x10901, 0x10902, 0x10903, 0x10904, 0x10905,
|
|
0x10906, 0x10907, 0x10908, 0x10909, 0x1090A, 0x1090B, 0x1090C, 0x1090D,
|
|
0x1090E, 0x1090F, 0x10910, 0x10911, 0x10912, 0x10913, 0x10914, 0x10915,
|
|
0x10916, 0x10917, 0x10918, 0x10919, 0x1091A, 0x1091B, 0x10920, 0x10921,
|
|
0x10922, 0x10923, 0x10924, 0x10925, 0x10926, 0x10927, 0x10928, 0x10929,
|
|
0x1092A, 0x1092B, 0x1092C, 0x1092D, 0x1092E, 0x1092F, 0x10930, 0x10931,
|
|
0x10932, 0x10933, 0x10934, 0x10935, 0x10936, 0x10937, 0x10938, 0x10939,
|
|
0x1093F, 0x10980, 0x10981, 0x10982, 0x10983, 0x10984, 0x10985, 0x10986,
|
|
0x10987, 0x10988, 0x10989, 0x1098A, 0x1098B, 0x1098C, 0x1098D, 0x1098E,
|
|
0x1098F, 0x10990, 0x10991, 0x10992, 0x10993, 0x10994, 0x10995, 0x10996,
|
|
0x10997, 0x10998, 0x10999, 0x1099A, 0x1099B, 0x1099C, 0x1099D, 0x1099E,
|
|
0x1099F, 0x109A0, 0x109A1, 0x109A2, 0x109A3, 0x109A4, 0x109A5, 0x109A6,
|
|
0x109A7, 0x109A8, 0x109A9, 0x109AA, 0x109AB, 0x109AC, 0x109AD, 0x109AE,
|
|
0x109AF, 0x109B0, 0x109B1, 0x109B2, 0x109B3, 0x109B4, 0x109B5, 0x109B6,
|
|
0x109B7, 0x109BE, 0x109BF, 0x10A00, 0x10A10, 0x10A11, 0x10A12, 0x10A13,
|
|
0x10A15, 0x10A16, 0x10A17, 0x10A19, 0x10A1A, 0x10A1B, 0x10A1C, 0x10A1D,
|
|
0x10A1E, 0x10A1F, 0x10A20, 0x10A21, 0x10A22, 0x10A23, 0x10A24, 0x10A25,
|
|
0x10A26, 0x10A27, 0x10A28, 0x10A29, 0x10A2A, 0x10A2B, 0x10A2C, 0x10A2D,
|
|
0x10A2E, 0x10A2F, 0x10A30, 0x10A31, 0x10A32, 0x10A33, 0x10A40, 0x10A41,
|
|
0x10A42, 0x10A43, 0x10A44, 0x10A45, 0x10A46, 0x10A47, 0x10A50, 0x10A51,
|
|
0x10A52, 0x10A53, 0x10A54, 0x10A55, 0x10A56, 0x10A57, 0x10A58, 0x10A60,
|
|
0x10A61, 0x10A62, 0x10A63, 0x10A64, 0x10A65, 0x10A66, 0x10A67, 0x10A68,
|
|
0x10A69, 0x10A6A, 0x10A6B, 0x10A6C, 0x10A6D, 0x10A6E, 0x10A6F, 0x10A70,
|
|
0x10A71, 0x10A72, 0x10A73, 0x10A74, 0x10A75, 0x10A76, 0x10A77, 0x10A78,
|
|
0x10A79, 0x10A7A, 0x10A7B, 0x10A7C, 0x10A7D, 0x10A7E, 0x10A7F, 0x10B00,
|
|
0x10B01, 0x10B02, 0x10B03, 0x10B04, 0x10B05, 0x10B06, 0x10B07, 0x10B08,
|
|
0x10B09, 0x10B0A, 0x10B0B, 0x10B0C, 0x10B0D, 0x10B0E, 0x10B0F, 0x10B10,
|
|
0x10B11, 0x10B12, 0x10B13, 0x10B14, 0x10B15, 0x10B16, 0x10B17, 0x10B18,
|
|
0x10B19, 0x10B1A, 0x10B1B, 0x10B1C, 0x10B1D, 0x10B1E, 0x10B1F, 0x10B20,
|
|
0x10B21, 0x10B22, 0x10B23, 0x10B24, 0x10B25, 0x10B26, 0x10B27, 0x10B28,
|
|
0x10B29, 0x10B2A, 0x10B2B, 0x10B2C, 0x10B2D, 0x10B2E, 0x10B2F, 0x10B30,
|
|
0x10B31, 0x10B32, 0x10B33, 0x10B34, 0x10B35, 0x10B40, 0x10B41, 0x10B42,
|
|
0x10B43, 0x10B44, 0x10B45, 0x10B46, 0x10B47, 0x10B48, 0x10B49, 0x10B4A,
|
|
0x10B4B, 0x10B4C, 0x10B4D, 0x10B4E, 0x10B4F, 0x10B50, 0x10B51, 0x10B52,
|
|
0x10B53, 0x10B54, 0x10B55, 0x10B58, 0x10B59, 0x10B5A, 0x10B5B, 0x10B5C,
|
|
0x10B5D, 0x10B5E, 0x10B5F, 0x10B60, 0x10B61, 0x10B62, 0x10B63, 0x10B64,
|
|
0x10B65, 0x10B66, 0x10B67, 0x10B68, 0x10B69, 0x10B6A, 0x10B6B, 0x10B6C,
|
|
0x10B6D, 0x10B6E, 0x10B6F, 0x10B70, 0x10B71, 0x10B72, 0x10B78, 0x10B79,
|
|
0x10B7A, 0x10B7B, 0x10B7C, 0x10B7D, 0x10B7E, 0x10B7F, 0x10C00, 0x10C01,
|
|
0x10C02, 0x10C03, 0x10C04, 0x10C05, 0x10C06, 0x10C07, 0x10C08, 0x10C09,
|
|
0x10C0A, 0x10C0B, 0x10C0C, 0x10C0D, 0x10C0E, 0x10C0F, 0x10C10, 0x10C11,
|
|
0x10C12, 0x10C13, 0x10C14, 0x10C15, 0x10C16, 0x10C17, 0x10C18, 0x10C19,
|
|
0x10C1A, 0x10C1B, 0x10C1C, 0x10C1D, 0x10C1E, 0x10C1F, 0x10C20, 0x10C21,
|
|
0x10C22, 0x10C23, 0x10C24, 0x10C25, 0x10C26, 0x10C27, 0x10C28, 0x10C29,
|
|
0x10C2A, 0x10C2B, 0x10C2C, 0x10C2D, 0x10C2E, 0x10C2F, 0x10C30, 0x10C31,
|
|
0x10C32, 0x10C33, 0x10C34, 0x10C35, 0x10C36, 0x10C37, 0x10C38, 0x10C39,
|
|
0x10C3A, 0x10C3B, 0x10C3C, 0x10C3D, 0x10C3E, 0x10C3F, 0x10C40, 0x10C41,
|
|
0x10C42, 0x10C43, 0x10C44, 0x10C45, 0x10C46, 0x10C47, 0x10C48, 0x1EE00,
|
|
0x1EE01, 0x1EE02, 0x1EE03, 0x1EE05, 0x1EE06, 0x1EE07, 0x1EE08, 0x1EE09,
|
|
0x1EE0A, 0x1EE0B, 0x1EE0C, 0x1EE0D, 0x1EE0E, 0x1EE0F, 0x1EE10, 0x1EE11,
|
|
0x1EE12, 0x1EE13, 0x1EE14, 0x1EE15, 0x1EE16, 0x1EE17, 0x1EE18, 0x1EE19,
|
|
0x1EE1A, 0x1EE1B, 0x1EE1C, 0x1EE1D, 0x1EE1E, 0x1EE1F, 0x1EE21, 0x1EE22,
|
|
0x1EE24, 0x1EE27, 0x1EE29, 0x1EE2A, 0x1EE2B, 0x1EE2C, 0x1EE2D, 0x1EE2E,
|
|
0x1EE2F, 0x1EE30, 0x1EE31, 0x1EE32, 0x1EE34, 0x1EE35, 0x1EE36, 0x1EE37,
|
|
0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE4D, 0x1EE4E,
|
|
0x1EE4F, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D,
|
|
0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE67, 0x1EE68, 0x1EE69, 0x1EE6A,
|
|
0x1EE6C, 0x1EE6D, 0x1EE6E, 0x1EE6F, 0x1EE70, 0x1EE71, 0x1EE72, 0x1EE74,
|
|
0x1EE75, 0x1EE76, 0x1EE77, 0x1EE79, 0x1EE7A, 0x1EE7B, 0x1EE7C, 0x1EE7E,
|
|
0x1EE80, 0x1EE81, 0x1EE82, 0x1EE83, 0x1EE84, 0x1EE85, 0x1EE86, 0x1EE87,
|
|
0x1EE88, 0x1EE89, 0x1EE8B, 0x1EE8C, 0x1EE8D, 0x1EE8E, 0x1EE8F, 0x1EE90,
|
|
0x1EE91, 0x1EE92, 0x1EE93, 0x1EE94, 0x1EE95, 0x1EE96, 0x1EE97, 0x1EE98,
|
|
0x1EE99, 0x1EE9A, 0x1EE9B, 0x1EEA1, 0x1EEA2, 0x1EEA3, 0x1EEA5, 0x1EEA6,
|
|
0x1EEA7, 0x1EEA8, 0x1EEA9, 0x1EEAB, 0x1EEAC, 0x1EEAD, 0x1EEAE, 0x1EEAF,
|
|
0x1EEB0, 0x1EEB1, 0x1EEB2, 0x1EEB3, 0x1EEB4, 0x1EEB5, 0x1EEB6, 0x1EEB7,
|
|
0x1EEB8, 0x1EEB9, 0x1EEBA, 0x1EEBB, 0x10FFFD];
|
|
|
|
function determineBidi(cueDiv) {
|
|
var nodeStack = [],
|
|
text = "",
|
|
charCode;
|
|
|
|
if (!cueDiv || !cueDiv.childNodes) {
|
|
return "ltr";
|
|
}
|
|
|
|
function pushNodes(nodeStack, node) {
|
|
for (var i = node.childNodes.length - 1; i >= 0; i--) {
|
|
nodeStack.push(node.childNodes[i]);
|
|
}
|
|
}
|
|
|
|
function nextTextNode(nodeStack) {
|
|
if (!nodeStack || !nodeStack.length) {
|
|
return null;
|
|
}
|
|
|
|
var node = nodeStack.pop(),
|
|
text = node.textContent || node.innerText;
|
|
if (text) {
|
|
// TODO: This should match all unicode type B characters (paragraph
|
|
// separator characters). See issue #115.
|
|
var m = text.match(/^.*(\n|\r)/);
|
|
if (m) {
|
|
nodeStack.length = 0;
|
|
return m[0];
|
|
}
|
|
return text;
|
|
}
|
|
if (node.tagName === "ruby") {
|
|
return nextTextNode(nodeStack);
|
|
}
|
|
if (node.childNodes) {
|
|
pushNodes(nodeStack, node);
|
|
return nextTextNode(nodeStack);
|
|
}
|
|
}
|
|
|
|
pushNodes(nodeStack, cueDiv);
|
|
while ((text = nextTextNode(nodeStack))) {
|
|
for (var i = 0; i < text.length; i++) {
|
|
charCode = text.charCodeAt(i);
|
|
for (var j = 0; j < strongRTLChars.length; j++) {
|
|
if (strongRTLChars[j] === charCode) {
|
|
return "rtl";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return "ltr";
|
|
}
|
|
|
|
function computeLinePos(cue) {
|
|
if (typeof cue.line === "number" &&
|
|
(cue.snapToLines || (cue.line >= 0 && cue.line <= 100))) {
|
|
return cue.line;
|
|
}
|
|
if (!cue.track || !cue.track.textTrackList ||
|
|
!cue.track.textTrackList.mediaElement) {
|
|
return -1;
|
|
}
|
|
var track = cue.track,
|
|
trackList = track.textTrackList,
|
|
count = 0;
|
|
for (var i = 0; i < trackList.length && trackList[i] !== track; i++) {
|
|
if (trackList[i].mode === "showing") {
|
|
count++;
|
|
}
|
|
}
|
|
return ++count * -1;
|
|
}
|
|
|
|
function StyleBox() {
|
|
}
|
|
|
|
// Apply styles to a div. If there is no div passed then it defaults to the
|
|
// div on 'this'.
|
|
StyleBox.prototype.applyStyles = function(styles, div) {
|
|
div = div || this.div;
|
|
for (var prop in styles) {
|
|
if (styles.hasOwnProperty(prop)) {
|
|
div.style[prop] = styles[prop];
|
|
}
|
|
}
|
|
};
|
|
|
|
StyleBox.prototype.formatStyle = function(val, unit) {
|
|
return val === 0 ? 0 : val + unit;
|
|
};
|
|
|
|
// Constructs the computed display state of the cue (a div). Places the div
|
|
// into the overlay which should be a block level element (usually a div).
|
|
function CueStyleBox(window, cue, styleOptions) {
|
|
var isIE8 = (/MSIE\s8\.0/).test(navigator.userAgent);
|
|
var color = "rgba(255, 255, 255, 1)";
|
|
var backgroundColor = "rgba(0, 0, 0, 0.8)";
|
|
|
|
if (isIE8) {
|
|
color = "rgb(255, 255, 255)";
|
|
backgroundColor = "rgb(0, 0, 0)";
|
|
}
|
|
|
|
StyleBox.call(this);
|
|
this.cue = cue;
|
|
|
|
// Parse our cue's text into a DOM tree rooted at 'cueDiv'. This div will
|
|
// have inline positioning and will function as the cue background box.
|
|
this.cueDiv = parseContent(window, cue.text);
|
|
var styles = {
|
|
color: color,
|
|
backgroundColor: backgroundColor,
|
|
position: "relative",
|
|
left: 0,
|
|
right: 0,
|
|
top: 0,
|
|
bottom: 0,
|
|
display: "inline"
|
|
};
|
|
|
|
if (!isIE8) {
|
|
styles.writingMode = cue.vertical === "" ? "horizontal-tb"
|
|
: cue.vertical === "lr" ? "vertical-lr"
|
|
: "vertical-rl";
|
|
styles.unicodeBidi = "plaintext";
|
|
}
|
|
this.applyStyles(styles, this.cueDiv);
|
|
|
|
// Create an absolutely positioned div that will be used to position the cue
|
|
// div. Note, all WebVTT cue-setting alignments are equivalent to the CSS
|
|
// mirrors of them except "middle" which is "center" in CSS.
|
|
this.div = window.document.createElement("div");
|
|
styles = {
|
|
textAlign: cue.align === "middle" ? "center" : cue.align,
|
|
font: styleOptions.font,
|
|
whiteSpace: "pre-line",
|
|
position: "absolute"
|
|
};
|
|
|
|
if (!isIE8) {
|
|
styles.direction = determineBidi(this.cueDiv);
|
|
styles.writingMode = cue.vertical === "" ? "horizontal-tb"
|
|
: cue.vertical === "lr" ? "vertical-lr"
|
|
: "vertical-rl".
|
|
stylesunicodeBidi = "plaintext";
|
|
}
|
|
|
|
this.applyStyles(styles);
|
|
|
|
this.div.appendChild(this.cueDiv);
|
|
|
|
// Calculate the distance from the reference edge of the viewport to the text
|
|
// position of the cue box. The reference edge will be resolved later when
|
|
// the box orientation styles are applied.
|
|
var textPos = 0;
|
|
switch (cue.positionAlign) {
|
|
case "start":
|
|
textPos = cue.position;
|
|
break;
|
|
case "middle":
|
|
textPos = cue.position - (cue.size / 2);
|
|
break;
|
|
case "end":
|
|
textPos = cue.position - cue.size;
|
|
break;
|
|
}
|
|
|
|
// Horizontal box orientation; textPos is the distance from the left edge of the
|
|
// area to the left edge of the box and cue.size is the distance extending to
|
|
// the right from there.
|
|
if (cue.vertical === "") {
|
|
this.applyStyles({
|
|
left: this.formatStyle(textPos, "%"),
|
|
width: this.formatStyle(cue.size, "%")
|
|
});
|
|
// Vertical box orientation; textPos is the distance from the top edge of the
|
|
// area to the top edge of the box and cue.size is the height extending
|
|
// downwards from there.
|
|
} else {
|
|
this.applyStyles({
|
|
top: this.formatStyle(textPos, "%"),
|
|
height: this.formatStyle(cue.size, "%")
|
|
});
|
|
}
|
|
|
|
this.move = function(box) {
|
|
this.applyStyles({
|
|
top: this.formatStyle(box.top, "px"),
|
|
bottom: this.formatStyle(box.bottom, "px"),
|
|
left: this.formatStyle(box.left, "px"),
|
|
right: this.formatStyle(box.right, "px"),
|
|
height: this.formatStyle(box.height, "px"),
|
|
width: this.formatStyle(box.width, "px")
|
|
});
|
|
};
|
|
}
|
|
CueStyleBox.prototype = _objCreate(StyleBox.prototype);
|
|
CueStyleBox.prototype.constructor = CueStyleBox;
|
|
|
|
// Represents the co-ordinates of an Element in a way that we can easily
|
|
// compute things with such as if it overlaps or intersects with another Element.
|
|
// Can initialize it with either a StyleBox or another BoxPosition.
|
|
function BoxPosition(obj) {
|
|
var isIE8 = (/MSIE\s8\.0/).test(navigator.userAgent);
|
|
|
|
// Either a BoxPosition was passed in and we need to copy it, or a StyleBox
|
|
// was passed in and we need to copy the results of 'getBoundingClientRect'
|
|
// as the object returned is readonly. All co-ordinate values are in reference
|
|
// to the viewport origin (top left).
|
|
var lh, height, width, top;
|
|
if (obj.div) {
|
|
height = obj.div.offsetHeight;
|
|
width = obj.div.offsetWidth;
|
|
top = obj.div.offsetTop;
|
|
|
|
var rects = (rects = obj.div.childNodes) && (rects = rects[0]) &&
|
|
rects.getClientRects && rects.getClientRects();
|
|
obj = obj.div.getBoundingClientRect();
|
|
// In certain cases the outter div will be slightly larger then the sum of
|
|
// the inner div's lines. This could be due to bold text, etc, on some platforms.
|
|
// In this case we should get the average line height and use that. This will
|
|
// result in the desired behaviour.
|
|
lh = rects ? Math.max((rects[0] && rects[0].height) || 0, obj.height / rects.length)
|
|
: 0;
|
|
|
|
}
|
|
this.left = obj.left;
|
|
this.right = obj.right;
|
|
this.top = obj.top || top;
|
|
this.height = obj.height || height;
|
|
this.bottom = obj.bottom || (top + (obj.height || height));
|
|
this.width = obj.width || width;
|
|
this.lineHeight = lh !== undefined ? lh : obj.lineHeight;
|
|
|
|
if (isIE8 && !this.lineHeight) {
|
|
this.lineHeight = 13;
|
|
}
|
|
}
|
|
|
|
// Move the box along a particular axis. Optionally pass in an amount to move
|
|
// the box. If no amount is passed then the default is the line height of the
|
|
// box.
|
|
BoxPosition.prototype.move = function(axis, toMove) {
|
|
toMove = toMove !== undefined ? toMove : this.lineHeight;
|
|
switch (axis) {
|
|
case "+x":
|
|
this.left += toMove;
|
|
this.right += toMove;
|
|
break;
|
|
case "-x":
|
|
this.left -= toMove;
|
|
this.right -= toMove;
|
|
break;
|
|
case "+y":
|
|
this.top += toMove;
|
|
this.bottom += toMove;
|
|
break;
|
|
case "-y":
|
|
this.top -= toMove;
|
|
this.bottom -= toMove;
|
|
break;
|
|
}
|
|
};
|
|
|
|
// Check if this box overlaps another box, b2.
|
|
BoxPosition.prototype.overlaps = function(b2) {
|
|
return this.left < b2.right &&
|
|
this.right > b2.left &&
|
|
this.top < b2.bottom &&
|
|
this.bottom > b2.top;
|
|
};
|
|
|
|
// Check if this box overlaps any other boxes in boxes.
|
|
BoxPosition.prototype.overlapsAny = function(boxes) {
|
|
for (var i = 0; i < boxes.length; i++) {
|
|
if (this.overlaps(boxes[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// Check if this box is within another box.
|
|
BoxPosition.prototype.within = function(container) {
|
|
return this.top >= container.top &&
|
|
this.bottom <= container.bottom &&
|
|
this.left >= container.left &&
|
|
this.right <= container.right;
|
|
};
|
|
|
|
// Check if this box is entirely within the container or it is overlapping
|
|
// on the edge opposite of the axis direction passed. For example, if "+x" is
|
|
// passed and the box is overlapping on the left edge of the container, then
|
|
// return true.
|
|
BoxPosition.prototype.overlapsOppositeAxis = function(container, axis) {
|
|
switch (axis) {
|
|
case "+x":
|
|
return this.left < container.left;
|
|
case "-x":
|
|
return this.right > container.right;
|
|
case "+y":
|
|
return this.top < container.top;
|
|
case "-y":
|
|
return this.bottom > container.bottom;
|
|
}
|
|
};
|
|
|
|
// Find the percentage of the area that this box is overlapping with another
|
|
// box.
|
|
BoxPosition.prototype.intersectPercentage = function(b2) {
|
|
var x = Math.max(0, Math.min(this.right, b2.right) - Math.max(this.left, b2.left)),
|
|
y = Math.max(0, Math.min(this.bottom, b2.bottom) - Math.max(this.top, b2.top)),
|
|
intersectArea = x * y;
|
|
return intersectArea / (this.height * this.width);
|
|
};
|
|
|
|
// Convert the positions from this box to CSS compatible positions using
|
|
// the reference container's positions. This has to be done because this
|
|
// box's positions are in reference to the viewport origin, whereas, CSS
|
|
// values are in referecne to their respective edges.
|
|
BoxPosition.prototype.toCSSCompatValues = function(reference) {
|
|
return {
|
|
top: this.top - reference.top,
|
|
bottom: reference.bottom - this.bottom,
|
|
left: this.left - reference.left,
|
|
right: reference.right - this.right,
|
|
height: this.height,
|
|
width: this.width
|
|
};
|
|
};
|
|
|
|
// Get an object that represents the box's position without anything extra.
|
|
// Can pass a StyleBox, HTMLElement, or another BoxPositon.
|
|
BoxPosition.getSimpleBoxPosition = function(obj) {
|
|
var height = obj.div ? obj.div.offsetHeight : obj.tagName ? obj.offsetHeight : 0;
|
|
var width = obj.div ? obj.div.offsetWidth : obj.tagName ? obj.offsetWidth : 0;
|
|
var top = obj.div ? obj.div.offsetTop : obj.tagName ? obj.offsetTop : 0;
|
|
|
|
obj = obj.div ? obj.div.getBoundingClientRect() :
|
|
obj.tagName ? obj.getBoundingClientRect() : obj;
|
|
var ret = {
|
|
left: obj.left,
|
|
right: obj.right,
|
|
top: obj.top || top,
|
|
height: obj.height || height,
|
|
bottom: obj.bottom || (top + (obj.height || height)),
|
|
width: obj.width || width
|
|
};
|
|
return ret;
|
|
};
|
|
|
|
// Move a StyleBox to its specified, or next best, position. The containerBox
|
|
// is the box that contains the StyleBox, such as a div. boxPositions are
|
|
// a list of other boxes that the styleBox can't overlap with.
|
|
function moveBoxToLinePosition(window, styleBox, containerBox, boxPositions) {
|
|
|
|
// Find the best position for a cue box, b, on the video. The axis parameter
|
|
// is a list of axis, the order of which, it will move the box along. For example:
|
|
// Passing ["+x", "-x"] will move the box first along the x axis in the positive
|
|
// direction. If it doesn't find a good position for it there it will then move
|
|
// it along the x axis in the negative direction.
|
|
function findBestPosition(b, axis) {
|
|
var bestPosition,
|
|
specifiedPosition = new BoxPosition(b),
|
|
percentage = 1; // Highest possible so the first thing we get is better.
|
|
|
|
for (var i = 0; i < axis.length; i++) {
|
|
while (b.overlapsOppositeAxis(containerBox, axis[i]) ||
|
|
(b.within(containerBox) && b.overlapsAny(boxPositions))) {
|
|
b.move(axis[i]);
|
|
}
|
|
// We found a spot where we aren't overlapping anything. This is our
|
|
// best position.
|
|
if (b.within(containerBox)) {
|
|
return b;
|
|
}
|
|
var p = b.intersectPercentage(containerBox);
|
|
// If we're outside the container box less then we were on our last try
|
|
// then remember this position as the best position.
|
|
if (percentage > p) {
|
|
bestPosition = new BoxPosition(b);
|
|
percentage = p;
|
|
}
|
|
// Reset the box position to the specified position.
|
|
b = new BoxPosition(specifiedPosition);
|
|
}
|
|
return bestPosition || specifiedPosition;
|
|
}
|
|
|
|
var boxPosition = new BoxPosition(styleBox),
|
|
cue = styleBox.cue,
|
|
linePos = computeLinePos(cue),
|
|
axis = [];
|
|
|
|
// If we have a line number to align the cue to.
|
|
if (cue.snapToLines) {
|
|
var size;
|
|
switch (cue.vertical) {
|
|
case "":
|
|
axis = [ "+y", "-y" ];
|
|
size = "height";
|
|
break;
|
|
case "rl":
|
|
axis = [ "+x", "-x" ];
|
|
size = "width";
|
|
break;
|
|
case "lr":
|
|
axis = [ "-x", "+x" ];
|
|
size = "width";
|
|
break;
|
|
}
|
|
|
|
var step = boxPosition.lineHeight,
|
|
position = step * Math.round(linePos),
|
|
maxPosition = containerBox[size] + step,
|
|
initialAxis = axis[0];
|
|
|
|
// If the specified intial position is greater then the max position then
|
|
// clamp the box to the amount of steps it would take for the box to
|
|
// reach the max position.
|
|
if (Math.abs(position) > maxPosition) {
|
|
position = position < 0 ? -1 : 1;
|
|
position *= Math.ceil(maxPosition / step) * step;
|
|
}
|
|
|
|
// If computed line position returns negative then line numbers are
|
|
// relative to the bottom of the video instead of the top. Therefore, we
|
|
// need to increase our initial position by the length or width of the
|
|
// video, depending on the writing direction, and reverse our axis directions.
|
|
if (linePos < 0) {
|
|
position += cue.vertical === "" ? containerBox.height : containerBox.width;
|
|
axis = axis.reverse();
|
|
}
|
|
|
|
// Move the box to the specified position. This may not be its best
|
|
// position.
|
|
boxPosition.move(initialAxis, position);
|
|
|
|
} else {
|
|
// If we have a percentage line value for the cue.
|
|
var calculatedPercentage = (boxPosition.lineHeight / containerBox.height) * 100;
|
|
|
|
switch (cue.lineAlign) {
|
|
case "middle":
|
|
linePos -= (calculatedPercentage / 2);
|
|
break;
|
|
case "end":
|
|
linePos -= calculatedPercentage;
|
|
break;
|
|
}
|
|
|
|
// Apply initial line position to the cue box.
|
|
switch (cue.vertical) {
|
|
case "":
|
|
styleBox.applyStyles({
|
|
top: styleBox.formatStyle(linePos, "%")
|
|
});
|
|
break;
|
|
case "rl":
|
|
styleBox.applyStyles({
|
|
left: styleBox.formatStyle(linePos, "%")
|
|
});
|
|
break;
|
|
case "lr":
|
|
styleBox.applyStyles({
|
|
right: styleBox.formatStyle(linePos, "%")
|
|
});
|
|
break;
|
|
}
|
|
|
|
axis = [ "+y", "-x", "+x", "-y" ];
|
|
|
|
// Get the box position again after we've applied the specified positioning
|
|
// to it.
|
|
boxPosition = new BoxPosition(styleBox);
|
|
}
|
|
|
|
var bestPosition = findBestPosition(boxPosition, axis);
|
|
styleBox.move(bestPosition.toCSSCompatValues(containerBox));
|
|
}
|
|
|
|
function WebVTT() {
|
|
// Nothing
|
|
}
|
|
|
|
// Helper to allow strings to be decoded instead of the default binary utf8 data.
|
|
WebVTT.StringDecoder = function() {
|
|
return {
|
|
decode: function(data) {
|
|
if (!data) {
|
|
return "";
|
|
}
|
|
if (typeof data !== "string") {
|
|
throw new Error("Error - expected string data.");
|
|
}
|
|
return decodeURIComponent(encodeURIComponent(data));
|
|
}
|
|
};
|
|
};
|
|
|
|
WebVTT.convertCueToDOMTree = function(window, cuetext) {
|
|
if (!window || !cuetext) {
|
|
return null;
|
|
}
|
|
return parseContent(window, cuetext);
|
|
};
|
|
|
|
var FONT_SIZE_PERCENT = 0.05;
|
|
var FONT_STYLE = "sans-serif";
|
|
var CUE_BACKGROUND_PADDING = "1.5%";
|
|
|
|
// Runs the processing model over the cues and regions passed to it.
|
|
// @param overlay A block level element (usually a div) that the computed cues
|
|
// and regions will be placed into.
|
|
WebVTT.processCues = function(window, cues, overlay) {
|
|
if (!window || !cues || !overlay) {
|
|
return null;
|
|
}
|
|
|
|
// Remove all previous children.
|
|
while (overlay.firstChild) {
|
|
overlay.removeChild(overlay.firstChild);
|
|
}
|
|
|
|
var paddedOverlay = window.document.createElement("div");
|
|
paddedOverlay.style.position = "absolute";
|
|
paddedOverlay.style.left = "0";
|
|
paddedOverlay.style.right = "0";
|
|
paddedOverlay.style.top = "0";
|
|
paddedOverlay.style.bottom = "0";
|
|
paddedOverlay.style.margin = CUE_BACKGROUND_PADDING;
|
|
overlay.appendChild(paddedOverlay);
|
|
|
|
// Determine if we need to compute the display states of the cues. This could
|
|
// be the case if a cue's state has been changed since the last computation or
|
|
// if it has not been computed yet.
|
|
function shouldCompute(cues) {
|
|
for (var i = 0; i < cues.length; i++) {
|
|
if (cues[i].hasBeenReset || !cues[i].displayState) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// We don't need to recompute the cues' display states. Just reuse them.
|
|
if (!shouldCompute(cues)) {
|
|
for (var i = 0; i < cues.length; i++) {
|
|
paddedOverlay.appendChild(cues[i].displayState);
|
|
}
|
|
return;
|
|
}
|
|
|
|
var boxPositions = [],
|
|
containerBox = BoxPosition.getSimpleBoxPosition(paddedOverlay),
|
|
fontSize = Math.round(containerBox.height * FONT_SIZE_PERCENT * 100) / 100;
|
|
var styleOptions = {
|
|
font: fontSize + "px " + FONT_STYLE
|
|
};
|
|
|
|
(function() {
|
|
var styleBox, cue;
|
|
|
|
for (var i = 0; i < cues.length; i++) {
|
|
cue = cues[i];
|
|
|
|
// Compute the intial position and styles of the cue div.
|
|
styleBox = new CueStyleBox(window, cue, styleOptions);
|
|
paddedOverlay.appendChild(styleBox.div);
|
|
|
|
// Move the cue div to it's correct line position.
|
|
moveBoxToLinePosition(window, styleBox, containerBox, boxPositions);
|
|
|
|
// Remember the computed div so that we don't have to recompute it later
|
|
// if we don't have too.
|
|
cue.displayState = styleBox.div;
|
|
|
|
boxPositions.push(BoxPosition.getSimpleBoxPosition(styleBox));
|
|
}
|
|
})();
|
|
};
|
|
|
|
WebVTT.Parser = function(window, vttjs, decoder) {
|
|
if (!decoder) {
|
|
decoder = vttjs;
|
|
vttjs = {};
|
|
}
|
|
if (!vttjs) {
|
|
vttjs = {};
|
|
}
|
|
|
|
this.window = window;
|
|
this.vttjs = vttjs;
|
|
this.state = "INITIAL";
|
|
this.buffer = "";
|
|
this.decoder = decoder || new TextDecoder("utf8");
|
|
this.regionList = [];
|
|
};
|
|
|
|
WebVTT.Parser.prototype = {
|
|
// If the error is a ParsingError then report it to the consumer if
|
|
// possible. If it's not a ParsingError then throw it like normal.
|
|
reportOrThrowError: function(e) {
|
|
if (e instanceof ParsingError) {
|
|
this.onparsingerror && this.onparsingerror(e);
|
|
} else {
|
|
throw e;
|
|
}
|
|
},
|
|
parse: function (data) {
|
|
var self = this;
|
|
|
|
// If there is no data then we won't decode it, but will just try to parse
|
|
// whatever is in buffer already. This may occur in circumstances, for
|
|
// example when flush() is called.
|
|
if (data) {
|
|
// Try to decode the data that we received.
|
|
self.buffer += self.decoder.decode(data, {stream: true});
|
|
}
|
|
|
|
function collectNextLine() {
|
|
var buffer = self.buffer;
|
|
var pos = 0;
|
|
while (pos < buffer.length && buffer[pos] !== '\r' && buffer[pos] !== '\n') {
|
|
++pos;
|
|
}
|
|
var line = buffer.substr(0, pos);
|
|
// Advance the buffer early in case we fail below.
|
|
if (buffer[pos] === '\r') {
|
|
++pos;
|
|
}
|
|
if (buffer[pos] === '\n') {
|
|
++pos;
|
|
}
|
|
self.buffer = buffer.substr(pos);
|
|
return line;
|
|
}
|
|
|
|
// 3.4 WebVTT region and WebVTT region settings syntax
|
|
function parseRegion(input) {
|
|
var settings = new Settings();
|
|
|
|
parseOptions(input, function (k, v) {
|
|
switch (k) {
|
|
case "id":
|
|
settings.set(k, v);
|
|
break;
|
|
case "width":
|
|
settings.percent(k, v);
|
|
break;
|
|
case "lines":
|
|
settings.integer(k, v);
|
|
break;
|
|
case "regionanchor":
|
|
case "viewportanchor":
|
|
var xy = v.split(',');
|
|
if (xy.length !== 2) {
|
|
break;
|
|
}
|
|
// We have to make sure both x and y parse, so use a temporary
|
|
// settings object here.
|
|
var anchor = new Settings();
|
|
anchor.percent("x", xy[0]);
|
|
anchor.percent("y", xy[1]);
|
|
if (!anchor.has("x") || !anchor.has("y")) {
|
|
break;
|
|
}
|
|
settings.set(k + "X", anchor.get("x"));
|
|
settings.set(k + "Y", anchor.get("y"));
|
|
break;
|
|
case "scroll":
|
|
settings.alt(k, v, ["up"]);
|
|
break;
|
|
}
|
|
}, /=/, /\s/);
|
|
|
|
// Create the region, using default values for any values that were not
|
|
// specified.
|
|
if (settings.has("id")) {
|
|
var region = new (self.vttjs.VTTRegion || self.window.VTTRegion)();
|
|
region.width = settings.get("width", 100);
|
|
region.lines = settings.get("lines", 3);
|
|
region.regionAnchorX = settings.get("regionanchorX", 0);
|
|
region.regionAnchorY = settings.get("regionanchorY", 100);
|
|
region.viewportAnchorX = settings.get("viewportanchorX", 0);
|
|
region.viewportAnchorY = settings.get("viewportanchorY", 100);
|
|
region.scroll = settings.get("scroll", "");
|
|
// Register the region.
|
|
self.onregion && self.onregion(region);
|
|
// Remember the VTTRegion for later in case we parse any VTTCues that
|
|
// reference it.
|
|
self.regionList.push({
|
|
id: settings.get("id"),
|
|
region: region
|
|
});
|
|
}
|
|
}
|
|
|
|
// 3.2 WebVTT metadata header syntax
|
|
function parseHeader(input) {
|
|
parseOptions(input, function (k, v) {
|
|
switch (k) {
|
|
case "Region":
|
|
// 3.3 WebVTT region metadata header syntax
|
|
parseRegion(v);
|
|
break;
|
|
}
|
|
}, /:/);
|
|
}
|
|
|
|
// 5.1 WebVTT file parsing.
|
|
try {
|
|
var line;
|
|
if (self.state === "INITIAL") {
|
|
// We can't start parsing until we have the first line.
|
|
if (!/\r\n|\n/.test(self.buffer)) {
|
|
return this;
|
|
}
|
|
|
|
line = collectNextLine();
|
|
|
|
var m = line.match(/^WEBVTT([ \t].*)?$/);
|
|
if (!m || !m[0]) {
|
|
throw new ParsingError(ParsingError.Errors.BadSignature);
|
|
}
|
|
|
|
self.state = "HEADER";
|
|
}
|
|
|
|
var alreadyCollectedLine = false;
|
|
while (self.buffer) {
|
|
// We can't parse a line until we have the full line.
|
|
if (!/\r\n|\n/.test(self.buffer)) {
|
|
return this;
|
|
}
|
|
|
|
if (!alreadyCollectedLine) {
|
|
line = collectNextLine();
|
|
} else {
|
|
alreadyCollectedLine = false;
|
|
}
|
|
|
|
switch (self.state) {
|
|
case "HEADER":
|
|
// 13-18 - Allow a header (metadata) under the WEBVTT line.
|
|
if (/:/.test(line)) {
|
|
parseHeader(line);
|
|
} else if (!line) {
|
|
// An empty line terminates the header and starts the body (cues).
|
|
self.state = "ID";
|
|
}
|
|
continue;
|
|
case "NOTE":
|
|
// Ignore NOTE blocks.
|
|
if (!line) {
|
|
self.state = "ID";
|
|
}
|
|
continue;
|
|
case "ID":
|
|
// Check for the start of NOTE blocks.
|
|
if (/^NOTE($|[ \t])/.test(line)) {
|
|
self.state = "NOTE";
|
|
break;
|
|
}
|
|
// 19-29 - Allow any number of line terminators, then initialize new cue values.
|
|
if (!line) {
|
|
continue;
|
|
}
|
|
self.cue = new (self.vttjs.VTTCue || self.window.VTTCue)(0, 0, "");
|
|
self.state = "CUE";
|
|
// 30-39 - Check if self line contains an optional identifier or timing data.
|
|
if (line.indexOf("-->") === -1) {
|
|
self.cue.id = line;
|
|
continue;
|
|
}
|
|
// Process line as start of a cue.
|
|
/*falls through*/
|
|
case "CUE":
|
|
// 40 - Collect cue timings and settings.
|
|
try {
|
|
parseCue(line, self.cue, self.regionList);
|
|
} catch (e) {
|
|
self.reportOrThrowError(e);
|
|
// In case of an error ignore rest of the cue.
|
|
self.cue = null;
|
|
self.state = "BADCUE";
|
|
continue;
|
|
}
|
|
self.state = "CUETEXT";
|
|
continue;
|
|
case "CUETEXT":
|
|
var hasSubstring = line.indexOf("-->") !== -1;
|
|
// 34 - If we have an empty line then report the cue.
|
|
// 35 - If we have the special substring '-->' then report the cue,
|
|
// but do not collect the line as we need to process the current
|
|
// one as a new cue.
|
|
if (!line || hasSubstring && (alreadyCollectedLine = true)) {
|
|
// We are done parsing self cue.
|
|
self.oncue && self.oncue(self.cue);
|
|
self.cue = null;
|
|
self.state = "ID";
|
|
continue;
|
|
}
|
|
if (self.cue.text) {
|
|
self.cue.text += "\n";
|
|
}
|
|
self.cue.text += line;
|
|
continue;
|
|
case "BADCUE": // BADCUE
|
|
// 54-62 - Collect and discard the remaining cue.
|
|
if (!line) {
|
|
self.state = "ID";
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
self.reportOrThrowError(e);
|
|
|
|
// If we are currently parsing a cue, report what we have.
|
|
if (self.state === "CUETEXT" && self.cue && self.oncue) {
|
|
self.oncue(self.cue);
|
|
}
|
|
self.cue = null;
|
|
// Enter BADWEBVTT state if header was not parsed correctly otherwise
|
|
// another exception occurred so enter BADCUE state.
|
|
self.state = self.state === "INITIAL" ? "BADWEBVTT" : "BADCUE";
|
|
}
|
|
return this;
|
|
},
|
|
flush: function () {
|
|
var self = this;
|
|
try {
|
|
// Finish decoding the stream.
|
|
self.buffer += self.decoder.decode();
|
|
// Synthesize the end of the current cue or region.
|
|
if (self.cue || self.state === "HEADER") {
|
|
self.buffer += "\n\n";
|
|
self.parse();
|
|
}
|
|
// If we've flushed, parsed, and we're still on the INITIAL state then
|
|
// that means we don't have enough of the stream to parse the first
|
|
// line.
|
|
if (self.state === "INITIAL") {
|
|
throw new ParsingError(ParsingError.Errors.BadSignature);
|
|
}
|
|
} catch(e) {
|
|
self.reportOrThrowError(e);
|
|
}
|
|
self.onflush && self.onflush();
|
|
return this;
|
|
}
|
|
};
|
|
|
|
global.WebVTT = WebVTT;
|
|
|
|
}(this, (this.vttjs || {})));
|
|
/**
|
|
* videojs-contrib-hls
|
|
* @version 3.0.2
|
|
* @copyright 2016 Brightcove, Inc
|
|
* @license Apache-2.0
|
|
*/
|
|
(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.videojsContribHls = 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){
|
|
/**
|
|
* @file bin-utils.js
|
|
*/
|
|
|
|
/**
|
|
* convert a TimeRange to text
|
|
*
|
|
* @param {TimeRange} range the timerange to use for conversion
|
|
* @param {Number} i the iterator on the range to convert
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
var textRange = function textRange(range, i) {
|
|
return range.start(i) + '-' + range.end(i);
|
|
};
|
|
|
|
/**
|
|
* format a number as hex string
|
|
*
|
|
* @param {Number} e The number
|
|
* @param {Number} i the iterator
|
|
*/
|
|
var formatHexString = function formatHexString(e, i) {
|
|
var value = e.toString(16);
|
|
|
|
return '00'.substring(0, 2 - value.length) + value + (i % 2 ? ' ' : '');
|
|
};
|
|
var formatAsciiString = function formatAsciiString(e) {
|
|
if (e >= 0x20 && e < 0x7e) {
|
|
return String.fromCharCode(e);
|
|
}
|
|
return '.';
|
|
};
|
|
|
|
/**
|
|
* utils to help dump binary data to the console
|
|
*/
|
|
var utils = {
|
|
hexDump: function hexDump(data) {
|
|
var bytes = Array.prototype.slice.call(data);
|
|
var step = 16;
|
|
var result = '';
|
|
var hex = undefined;
|
|
var ascii = undefined;
|
|
|
|
for (var j = 0; j < bytes.length / step; j++) {
|
|
hex = bytes.slice(j * step, j * step + step).map(formatHexString).join('');
|
|
ascii = bytes.slice(j * step, j * step + step).map(formatAsciiString).join('');
|
|
result += hex + ' ' + ascii + '\n';
|
|
}
|
|
return result;
|
|
},
|
|
tagDump: function tagDump(tag) {
|
|
return utils.hexDump(tag.bytes);
|
|
},
|
|
textRanges: function textRanges(ranges) {
|
|
var result = '';
|
|
var i = undefined;
|
|
|
|
for (i = 0; i < ranges.length; i++) {
|
|
result += textRange(ranges, i) + ' ';
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
exports['default'] = utils;
|
|
module.exports = exports['default'];
|
|
},{}],2:[function(require,module,exports){
|
|
/**
|
|
* @file decrypter/aes.js
|
|
*
|
|
* This file contains an adaptation of the AES decryption algorithm
|
|
* from the Standford Javascript Cryptography Library. That work is
|
|
* covered by the following copyright and permissions notice:
|
|
*
|
|
* Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* The views and conclusions contained in the software and documentation
|
|
* are those of the authors and should not be interpreted as representing
|
|
* official policies, either expressed or implied, of the authors.
|
|
*/
|
|
|
|
/**
|
|
* Expand the S-box tables.
|
|
*
|
|
* @private
|
|
*/
|
|
'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'); } }
|
|
|
|
var precompute = function precompute() {
|
|
var tables = [[[], [], [], [], []], [[], [], [], [], []]];
|
|
var encTable = tables[0];
|
|
var decTable = tables[1];
|
|
var sbox = encTable[4];
|
|
var sboxInv = decTable[4];
|
|
var i = undefined;
|
|
var x = undefined;
|
|
var xInv = undefined;
|
|
var d = [];
|
|
var th = [];
|
|
var x2 = undefined;
|
|
var x4 = undefined;
|
|
var x8 = undefined;
|
|
var s = undefined;
|
|
var tEnc = undefined;
|
|
var tDec = undefined;
|
|
|
|
// Compute double and third tables
|
|
for (i = 0; i < 256; i++) {
|
|
th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
|
|
}
|
|
|
|
for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
|
|
// Compute sbox
|
|
s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
|
|
s = s >> 8 ^ s & 255 ^ 99;
|
|
sbox[x] = s;
|
|
sboxInv[s] = x;
|
|
|
|
// Compute MixColumns
|
|
x8 = d[x4 = d[x2 = d[x]]];
|
|
tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
|
|
tEnc = d[s] * 0x101 ^ s * 0x1010100;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
|
|
decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
|
|
}
|
|
}
|
|
|
|
// Compactify. Considerable speedup on Firefox.
|
|
for (i = 0; i < 5; i++) {
|
|
encTable[i] = encTable[i].slice(0);
|
|
decTable[i] = decTable[i].slice(0);
|
|
}
|
|
return tables;
|
|
};
|
|
var aesTables = null;
|
|
|
|
/**
|
|
* Schedule out an AES key for both encryption and decryption. This
|
|
* is a low-level class. Use a cipher mode to do bulk encryption.
|
|
*
|
|
* @class AES
|
|
* @param key {Array} The key as an array of 4, 6 or 8 words.
|
|
*/
|
|
|
|
var AES = (function () {
|
|
function AES(key) {
|
|
_classCallCheck(this, AES);
|
|
|
|
/**
|
|
* The expanded S-box and inverse S-box tables. These will be computed
|
|
* on the client so that we don't have to send them down the wire.
|
|
*
|
|
* There are two tables, _tables[0] is for encryption and
|
|
* _tables[1] is for decryption.
|
|
*
|
|
* The first 4 sub-tables are the expanded S-box with MixColumns. The
|
|
* last (_tables[01][4]) is the S-box itself.
|
|
*
|
|
* @private
|
|
*/
|
|
// if we have yet to precompute the S-box tables
|
|
// do so now
|
|
if (!aesTables) {
|
|
aesTables = precompute();
|
|
}
|
|
// then make a copy of that object for use
|
|
this._tables = [[aesTables[0][0].slice(), aesTables[0][1].slice(), aesTables[0][2].slice(), aesTables[0][3].slice(), aesTables[0][4].slice()], [aesTables[1][0].slice(), aesTables[1][1].slice(), aesTables[1][2].slice(), aesTables[1][3].slice(), aesTables[1][4].slice()]];
|
|
var i = undefined;
|
|
var j = undefined;
|
|
var tmp = undefined;
|
|
var encKey = undefined;
|
|
var decKey = undefined;
|
|
var sbox = this._tables[0][4];
|
|
var decTable = this._tables[1];
|
|
var keyLen = key.length;
|
|
var rcon = 1;
|
|
|
|
if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
|
|
throw new Error('Invalid aes key size');
|
|
}
|
|
|
|
encKey = key.slice(0);
|
|
decKey = [];
|
|
this._key = [encKey, decKey];
|
|
|
|
// schedule encryption keys
|
|
for (i = keyLen; i < 4 * keyLen + 28; i++) {
|
|
tmp = encKey[i - 1];
|
|
|
|
// apply sbox
|
|
if (i % keyLen === 0 || keyLen === 8 && i % keyLen === 4) {
|
|
tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];
|
|
|
|
// shift rows and add rcon
|
|
if (i % keyLen === 0) {
|
|
tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
|
|
rcon = rcon << 1 ^ (rcon >> 7) * 283;
|
|
}
|
|
}
|
|
|
|
encKey[i] = encKey[i - keyLen] ^ tmp;
|
|
}
|
|
|
|
// schedule decryption keys
|
|
for (j = 0; i; j++, i--) {
|
|
tmp = encKey[j & 3 ? i : i - 4];
|
|
if (i <= 4 || j < 4) {
|
|
decKey[j] = tmp;
|
|
} else {
|
|
decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decrypt 16 bytes, specified as four 32-bit words.
|
|
*
|
|
* @param {Number} encrypted0 the first word to decrypt
|
|
* @param {Number} encrypted1 the second word to decrypt
|
|
* @param {Number} encrypted2 the third word to decrypt
|
|
* @param {Number} encrypted3 the fourth word to decrypt
|
|
* @param {Int32Array} out the array to write the decrypted words
|
|
* into
|
|
* @param {Number} offset the offset into the output array to start
|
|
* writing results
|
|
* @return {Array} The plaintext.
|
|
*/
|
|
|
|
_createClass(AES, [{
|
|
key: 'decrypt',
|
|
value: function decrypt(encrypted0, encrypted1, encrypted2, encrypted3, out, offset) {
|
|
var key = this._key[1];
|
|
// state variables a,b,c,d are loaded with pre-whitened data
|
|
var a = encrypted0 ^ key[0];
|
|
var b = encrypted3 ^ key[1];
|
|
var c = encrypted2 ^ key[2];
|
|
var d = encrypted1 ^ key[3];
|
|
var a2 = undefined;
|
|
var b2 = undefined;
|
|
var c2 = undefined;
|
|
|
|
// key.length === 2 ?
|
|
var nInnerRounds = key.length / 4 - 2;
|
|
var i = undefined;
|
|
var kIndex = 4;
|
|
var table = this._tables[1];
|
|
|
|
// load up the tables
|
|
var table0 = table[0];
|
|
var table1 = table[1];
|
|
var table2 = table[2];
|
|
var table3 = table[3];
|
|
var sbox = table[4];
|
|
|
|
// Inner rounds. Cribbed from OpenSSL.
|
|
for (i = 0; i < nInnerRounds; i++) {
|
|
a2 = table0[a >>> 24] ^ table1[b >> 16 & 255] ^ table2[c >> 8 & 255] ^ table3[d & 255] ^ key[kIndex];
|
|
b2 = table0[b >>> 24] ^ table1[c >> 16 & 255] ^ table2[d >> 8 & 255] ^ table3[a & 255] ^ key[kIndex + 1];
|
|
c2 = table0[c >>> 24] ^ table1[d >> 16 & 255] ^ table2[a >> 8 & 255] ^ table3[b & 255] ^ key[kIndex + 2];
|
|
d = table0[d >>> 24] ^ table1[a >> 16 & 255] ^ table2[b >> 8 & 255] ^ table3[c & 255] ^ key[kIndex + 3];
|
|
kIndex += 4;
|
|
a = a2;b = b2;c = c2;
|
|
}
|
|
|
|
// Last round.
|
|
for (i = 0; i < 4; i++) {
|
|
out[(3 & -i) + offset] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
|
|
a2 = a;a = b;b = c;c = d;d = a2;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AES;
|
|
})();
|
|
|
|
exports['default'] = AES;
|
|
module.exports = exports['default'];
|
|
},{}],3:[function(require,module,exports){
|
|
/**
|
|
* @file decrypter/async-stream.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _stream = require('../stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
/**
|
|
* A wrapper around the Stream class to use setTiemout
|
|
* and run stream "jobs" Asynchronously
|
|
*
|
|
* @class AsyncStream
|
|
* @extends Stream
|
|
*/
|
|
|
|
var AsyncStream = (function (_Stream) {
|
|
_inherits(AsyncStream, _Stream);
|
|
|
|
function AsyncStream() {
|
|
_classCallCheck(this, AsyncStream);
|
|
|
|
_get(Object.getPrototypeOf(AsyncStream.prototype), 'constructor', this).call(this, _stream2['default']);
|
|
this.jobs = [];
|
|
this.delay = 1;
|
|
this.timeout_ = null;
|
|
}
|
|
|
|
/**
|
|
* process an async job
|
|
*
|
|
* @private
|
|
*/
|
|
|
|
_createClass(AsyncStream, [{
|
|
key: 'processJob_',
|
|
value: function processJob_() {
|
|
this.jobs.shift()();
|
|
if (this.jobs.length) {
|
|
this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
|
|
} else {
|
|
this.timeout_ = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* push a job into the stream
|
|
*
|
|
* @param {Function} job the job to push into the stream
|
|
*/
|
|
}, {
|
|
key: 'push',
|
|
value: function push(job) {
|
|
this.jobs.push(job);
|
|
if (!this.timeout_) {
|
|
this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AsyncStream;
|
|
})(_stream2['default']);
|
|
|
|
exports['default'] = AsyncStream;
|
|
module.exports = exports['default'];
|
|
},{"../stream":18}],4:[function(require,module,exports){
|
|
/**
|
|
* @file decrypter/decrypter.js
|
|
*
|
|
* An asynchronous implementation of AES-128 CBC decryption with
|
|
* PKCS#7 padding.
|
|
*/
|
|
|
|
'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 _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 _aes = require('./aes');
|
|
|
|
var _aes2 = _interopRequireDefault(_aes);
|
|
|
|
var _asyncStream = require('./async-stream');
|
|
|
|
var _asyncStream2 = _interopRequireDefault(_asyncStream);
|
|
|
|
var _pkcs7 = require('pkcs7');
|
|
|
|
/**
|
|
* Convert network-order (big-endian) bytes into their little-endian
|
|
* representation.
|
|
*/
|
|
var ntoh = function ntoh(word) {
|
|
return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
|
|
};
|
|
|
|
/**
|
|
* Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
|
|
*
|
|
* @param {Uint8Array} encrypted the encrypted bytes
|
|
* @param {Uint32Array} key the bytes of the decryption key
|
|
* @param {Uint32Array} initVector the initialization vector (IV) to
|
|
* use for the first round of CBC.
|
|
* @return {Uint8Array} the decrypted bytes
|
|
*
|
|
* @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
|
|
* @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
|
|
* @see https://tools.ietf.org/html/rfc2315
|
|
*/
|
|
var decrypt = function decrypt(encrypted, key, initVector) {
|
|
// word-level access to the encrypted bytes
|
|
var encrypted32 = new Int32Array(encrypted.buffer, encrypted.byteOffset, encrypted.byteLength >> 2);
|
|
|
|
var decipher = new _aes2['default'](Array.prototype.slice.call(key));
|
|
|
|
// byte and word-level access for the decrypted output
|
|
var decrypted = new Uint8Array(encrypted.byteLength);
|
|
var decrypted32 = new Int32Array(decrypted.buffer);
|
|
|
|
// temporary variables for working with the IV, encrypted, and
|
|
// decrypted data
|
|
var init0 = undefined;
|
|
var init1 = undefined;
|
|
var init2 = undefined;
|
|
var init3 = undefined;
|
|
var encrypted0 = undefined;
|
|
var encrypted1 = undefined;
|
|
var encrypted2 = undefined;
|
|
var encrypted3 = undefined;
|
|
|
|
// iteration variable
|
|
var wordIx = undefined;
|
|
|
|
// pull out the words of the IV to ensure we don't modify the
|
|
// passed-in reference and easier access
|
|
init0 = initVector[0];
|
|
init1 = initVector[1];
|
|
init2 = initVector[2];
|
|
init3 = initVector[3];
|
|
|
|
// decrypt four word sequences, applying cipher-block chaining (CBC)
|
|
// to each decrypted block
|
|
for (wordIx = 0; wordIx < encrypted32.length; wordIx += 4) {
|
|
// convert big-endian (network order) words into little-endian
|
|
// (javascript order)
|
|
encrypted0 = ntoh(encrypted32[wordIx]);
|
|
encrypted1 = ntoh(encrypted32[wordIx + 1]);
|
|
encrypted2 = ntoh(encrypted32[wordIx + 2]);
|
|
encrypted3 = ntoh(encrypted32[wordIx + 3]);
|
|
|
|
// decrypt the block
|
|
decipher.decrypt(encrypted0, encrypted1, encrypted2, encrypted3, decrypted32, wordIx);
|
|
|
|
// XOR with the IV, and restore network byte-order to obtain the
|
|
// plaintext
|
|
decrypted32[wordIx] = ntoh(decrypted32[wordIx] ^ init0);
|
|
decrypted32[wordIx + 1] = ntoh(decrypted32[wordIx + 1] ^ init1);
|
|
decrypted32[wordIx + 2] = ntoh(decrypted32[wordIx + 2] ^ init2);
|
|
decrypted32[wordIx + 3] = ntoh(decrypted32[wordIx + 3] ^ init3);
|
|
|
|
// setup the IV for the next round
|
|
init0 = encrypted0;
|
|
init1 = encrypted1;
|
|
init2 = encrypted2;
|
|
init3 = encrypted3;
|
|
}
|
|
|
|
return decrypted;
|
|
};
|
|
|
|
exports.decrypt = decrypt;
|
|
/**
|
|
* The `Decrypter` class that manages decryption of AES
|
|
* data through `AsyncStream` objects and the `decrypt`
|
|
* function
|
|
*
|
|
* @param {Uint8Array} encrypted the encrypted bytes
|
|
* @param {Uint32Array} key the bytes of the decryption key
|
|
* @param {Uint32Array} initVector the initialization vector (IV) to
|
|
* @param {Function} done the function to run when done
|
|
* @class Decrypter
|
|
*/
|
|
|
|
var Decrypter = (function () {
|
|
function Decrypter(encrypted, key, initVector, done) {
|
|
_classCallCheck(this, Decrypter);
|
|
|
|
var step = Decrypter.STEP;
|
|
var encrypted32 = new Int32Array(encrypted.buffer);
|
|
var decrypted = new Uint8Array(encrypted.byteLength);
|
|
var i = 0;
|
|
|
|
this.asyncStream_ = new _asyncStream2['default']();
|
|
|
|
// split up the encryption job and do the individual chunks asynchronously
|
|
this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
|
|
for (i = step; i < encrypted32.length; i += step) {
|
|
initVector = new Uint32Array([ntoh(encrypted32[i - 4]), ntoh(encrypted32[i - 3]), ntoh(encrypted32[i - 2]), ntoh(encrypted32[i - 1])]);
|
|
this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
|
|
}
|
|
// invoke the done() callback when everything is finished
|
|
this.asyncStream_.push(function () {
|
|
// remove pkcs#7 padding from the decrypted bytes
|
|
done(null, (0, _pkcs7.unpad)(decrypted));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* a getter for step the maximum number of bytes to process at one time
|
|
*
|
|
* @return {Number} the value of step 32000
|
|
*/
|
|
|
|
_createClass(Decrypter, [{
|
|
key: 'decryptChunk_',
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
value: function decryptChunk_(encrypted, key, initVector, decrypted) {
|
|
return function () {
|
|
var bytes = decrypt(encrypted, key, initVector);
|
|
|
|
decrypted.set(bytes, encrypted.byteOffset);
|
|
};
|
|
}
|
|
}], [{
|
|
key: 'STEP',
|
|
get: function get() {
|
|
// 4 * 8000;
|
|
return 32000;
|
|
}
|
|
}]);
|
|
|
|
return Decrypter;
|
|
})();
|
|
|
|
exports.Decrypter = Decrypter;
|
|
exports['default'] = {
|
|
Decrypter: Decrypter,
|
|
decrypt: decrypt
|
|
};
|
|
},{"./aes":2,"./async-stream":3,"pkcs7":23}],5:[function(require,module,exports){
|
|
/**
|
|
* @file decrypter/index.js
|
|
*
|
|
* Index module to easily import the primary components of AES-128
|
|
* decryption. Like this:
|
|
*
|
|
* ```js
|
|
* import {Decrypter, decrypt, AsyncStream} from './src/decrypter';
|
|
* ```
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _decrypter = require('./decrypter');
|
|
|
|
var _asyncStream = require('./async-stream');
|
|
|
|
var _asyncStream2 = _interopRequireDefault(_asyncStream);
|
|
|
|
exports['default'] = {
|
|
decrypt: _decrypter.decrypt,
|
|
Decrypter: _decrypter.Decrypter,
|
|
AsyncStream: _asyncStream2['default']
|
|
};
|
|
module.exports = exports['default'];
|
|
},{"./async-stream":3,"./decrypter":4}],6:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file hls-audio-track.js
|
|
*/
|
|
'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 _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _playlistLoader = require('./playlist-loader');
|
|
|
|
var _playlistLoader2 = _interopRequireDefault(_playlistLoader);
|
|
|
|
/**
|
|
* HlsAudioTrack extends video.js audio tracks but adds HLS
|
|
* specific data storage such as playlist loaders, mediaGroups
|
|
* and default/autoselect
|
|
*
|
|
* @param {Object} options options to create HlsAudioTrack with
|
|
* @class HlsAudioTrack
|
|
* @extends AudioTrack
|
|
*/
|
|
|
|
var HlsAudioTrack = (function (_AudioTrack) {
|
|
_inherits(HlsAudioTrack, _AudioTrack);
|
|
|
|
function HlsAudioTrack(options) {
|
|
_classCallCheck(this, HlsAudioTrack);
|
|
|
|
_get(Object.getPrototypeOf(HlsAudioTrack.prototype), 'constructor', this).call(this, {
|
|
kind: options['default'] ? 'main' : 'alternative',
|
|
enabled: options['default'] || false,
|
|
language: options.language,
|
|
label: options.label
|
|
});
|
|
|
|
this.hls = options.hls;
|
|
this.autoselect = options.autoselect || false;
|
|
this['default'] = options['default'] || false;
|
|
this.withCredentials = options.withCredentials || false;
|
|
this.mediaGroups_ = [];
|
|
this.addLoader(options.mediaGroup, options.resolvedUri);
|
|
}
|
|
|
|
/**
|
|
* get a PlaylistLoader from this track given a mediaGroup name
|
|
*
|
|
* @param {String} mediaGroup the mediaGroup to get the loader for
|
|
* @return {PlaylistLoader|Null} the PlaylistLoader or null
|
|
*/
|
|
|
|
_createClass(HlsAudioTrack, [{
|
|
key: 'getLoader',
|
|
value: function getLoader(mediaGroup) {
|
|
for (var i = 0; i < this.mediaGroups_.length; i++) {
|
|
var mgl = this.mediaGroups_[i];
|
|
|
|
if (mgl.mediaGroup === mediaGroup) {
|
|
return mgl.loader;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add a PlaylistLoader given a mediaGroup, and a uri. for a combined track
|
|
* we store null for the playlistloader
|
|
*
|
|
* @param {String} mediaGroup the mediaGroup to get the loader for
|
|
* @param {String} uri the uri to get the audio track/mediaGroup from
|
|
*/
|
|
}, {
|
|
key: 'addLoader',
|
|
value: function addLoader(mediaGroup) {
|
|
var uri = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
|
|
|
|
var loader = null;
|
|
|
|
if (uri) {
|
|
// TODO: this should probably happen upstream in Master Playlist
|
|
// Controller when we can switch PlaylistLoader sources
|
|
// then we can just store the uri here instead
|
|
loader = new _playlistLoader2['default'](uri, this.hls, this.withCredentials);
|
|
}
|
|
this.mediaGroups_.push({ mediaGroup: mediaGroup, loader: loader });
|
|
}
|
|
|
|
/**
|
|
* remove a playlist loader from a track given the mediaGroup
|
|
*
|
|
* @param {String} mediaGroup the mediaGroup to remove
|
|
*/
|
|
}, {
|
|
key: 'removeLoader',
|
|
value: function removeLoader(mediaGroup) {
|
|
for (var i = 0; i < this.mediaGroups_.length; i++) {
|
|
var mgl = this.mediaGroups_[i];
|
|
|
|
if (mgl.mediaGroup === mediaGroup) {
|
|
if (mgl.loader) {
|
|
mgl.loader.dispose();
|
|
}
|
|
this.mediaGroups_.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dispose of this audio track and
|
|
* the playlist loader that it holds inside
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
var i = this.mediaGroups_.length;
|
|
|
|
while (i--) {
|
|
this.removeLoader(this.mediaGroups_[i].mediaGroup);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return HlsAudioTrack;
|
|
})(_videoJs.AudioTrack);
|
|
|
|
exports['default'] = HlsAudioTrack;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./playlist-loader":12}],7:[function(require,module,exports){
|
|
/**
|
|
* @file m3u8/index.js
|
|
*
|
|
* Utilities for parsing M3U8 files. If the entire manifest is available,
|
|
* `Parser` will create an object representation with enough detail for managing
|
|
* playback. `ParseStream` and `LineStream` are lower-level parsing primitives
|
|
* that do not assume the entirety of the manifest is ready and expose a
|
|
* ReadableStream-like interface.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _lineStream = require('./line-stream');
|
|
|
|
var _lineStream2 = _interopRequireDefault(_lineStream);
|
|
|
|
var _parseStream = require('./parse-stream');
|
|
|
|
var _parseStream2 = _interopRequireDefault(_parseStream);
|
|
|
|
var _parser = require('./parser');
|
|
|
|
var _parser2 = _interopRequireDefault(_parser);
|
|
|
|
exports['default'] = {
|
|
LineStream: _lineStream2['default'],
|
|
ParseStream: _parseStream2['default'],
|
|
Parser: _parser2['default']
|
|
};
|
|
module.exports = exports['default'];
|
|
},{"./line-stream":8,"./parse-stream":9,"./parser":10}],8:[function(require,module,exports){
|
|
/**
|
|
* @file m3u8/line-stream.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _stream = require('../stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
/**
|
|
* A stream that buffers string input and generates a `data` event for each
|
|
* line.
|
|
*
|
|
* @class LineStream
|
|
* @extends Stream
|
|
*/
|
|
|
|
var LineStream = (function (_Stream) {
|
|
_inherits(LineStream, _Stream);
|
|
|
|
function LineStream() {
|
|
_classCallCheck(this, LineStream);
|
|
|
|
_get(Object.getPrototypeOf(LineStream.prototype), 'constructor', this).call(this);
|
|
this.buffer = '';
|
|
}
|
|
|
|
/**
|
|
* Add new data to be parsed.
|
|
*
|
|
* @param {String} data the text to process
|
|
*/
|
|
|
|
_createClass(LineStream, [{
|
|
key: 'push',
|
|
value: function push(data) {
|
|
var nextNewline = undefined;
|
|
|
|
this.buffer += data;
|
|
nextNewline = this.buffer.indexOf('\n');
|
|
|
|
for (; nextNewline > -1; nextNewline = this.buffer.indexOf('\n')) {
|
|
this.trigger('data', this.buffer.substring(0, nextNewline));
|
|
this.buffer = this.buffer.substring(nextNewline + 1);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return LineStream;
|
|
})(_stream2['default']);
|
|
|
|
exports['default'] = LineStream;
|
|
module.exports = exports['default'];
|
|
},{"../stream":18}],9:[function(require,module,exports){
|
|
/**
|
|
* @file m3u8/parse-stream.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _stream = require('../stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
/**
|
|
* "forgiving" attribute list psuedo-grammar:
|
|
* attributes -> keyvalue (',' keyvalue)*
|
|
* keyvalue -> key '=' value
|
|
* key -> [^=]*
|
|
* value -> '"' [^"]* '"' | [^,]*
|
|
*/
|
|
var attributeSeparator = function attributeSeparator() {
|
|
var key = '[^=]*';
|
|
var value = '"[^"]*"|[^,]*';
|
|
var keyvalue = '(?:' + key + ')=(?:' + value + ')';
|
|
|
|
return new RegExp('(?:^|,)(' + keyvalue + ')');
|
|
};
|
|
|
|
/**
|
|
* Parse attributes from a line given the seperator
|
|
*
|
|
* @param {String} attributes the attibute line to parse
|
|
*/
|
|
var parseAttributes = function parseAttributes(attributes) {
|
|
// split the string using attributes as the separator
|
|
var attrs = attributes.split(attributeSeparator());
|
|
var i = attrs.length;
|
|
var result = {};
|
|
var attr = undefined;
|
|
|
|
while (i--) {
|
|
// filter out unmatched portions of the string
|
|
if (attrs[i] === '') {
|
|
continue;
|
|
}
|
|
|
|
// split the key and value
|
|
attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1);
|
|
// trim whitespace and remove optional quotes around the value
|
|
attr[0] = attr[0].replace(/^\s+|\s+$/g, '');
|
|
attr[1] = attr[1].replace(/^\s+|\s+$/g, '');
|
|
attr[1] = attr[1].replace(/^['"](.*)['"]$/g, '$1');
|
|
result[attr[0]] = attr[1];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* A line-level M3U8 parser event stream. It expects to receive input one
|
|
* line at a time and performs a context-free parse of its contents. A stream
|
|
* interpretation of a manifest can be useful if the manifest is expected to
|
|
* be too large to fit comfortably into memory or the entirety of the input
|
|
* is not immediately available. Otherwise, it's probably much easier to work
|
|
* with a regular `Parser` object.
|
|
*
|
|
* Produces `data` events with an object that captures the parser's
|
|
* interpretation of the input. That object has a property `tag` that is one
|
|
* of `uri`, `comment`, or `tag`. URIs only have a single additional
|
|
* property, `line`, which captures the entirety of the input without
|
|
* interpretation. Comments similarly have a single additional property
|
|
* `text` which is the input without the leading `#`.
|
|
*
|
|
* Tags always have a property `tagType` which is the lower-cased version of
|
|
* the M3U8 directive without the `#EXT` or `#EXT-X-` prefix. For instance,
|
|
* `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
|
|
* tags are given the tag type `unknown` and a single additional property
|
|
* `data` with the remainder of the input.
|
|
*
|
|
* @class ParseStream
|
|
* @extends Stream
|
|
*/
|
|
|
|
var ParseStream = (function (_Stream) {
|
|
_inherits(ParseStream, _Stream);
|
|
|
|
function ParseStream() {
|
|
_classCallCheck(this, ParseStream);
|
|
|
|
_get(Object.getPrototypeOf(ParseStream.prototype), 'constructor', this).call(this);
|
|
}
|
|
|
|
/**
|
|
* Parses an additional line of input.
|
|
*
|
|
* @param {String} line a single line of an M3U8 file to parse
|
|
*/
|
|
|
|
_createClass(ParseStream, [{
|
|
key: 'push',
|
|
value: function push(line) {
|
|
var match = undefined;
|
|
var event = undefined;
|
|
|
|
// strip whitespace
|
|
line = line.replace(/^[\u0000\s]+|[\u0000\s]+$/g, '');
|
|
if (line.length === 0) {
|
|
// ignore empty lines
|
|
return;
|
|
}
|
|
|
|
// URIs
|
|
if (line[0] !== '#') {
|
|
this.trigger('data', {
|
|
type: 'uri',
|
|
uri: line
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Comments
|
|
if (line.indexOf('#EXT') !== 0) {
|
|
this.trigger('data', {
|
|
type: 'comment',
|
|
text: line.slice(1)
|
|
});
|
|
return;
|
|
}
|
|
|
|
// strip off any carriage returns here so the regex matching
|
|
// doesn't have to account for them.
|
|
line = line.replace('\r', '');
|
|
|
|
// Tags
|
|
match = /^#EXTM3U/.exec(line);
|
|
if (match) {
|
|
this.trigger('data', {
|
|
type: 'tag',
|
|
tagType: 'm3u'
|
|
});
|
|
return;
|
|
}
|
|
match = /^#EXTINF:?([0-9\.]*)?,?(.*)?$/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'inf'
|
|
};
|
|
if (match[1]) {
|
|
event.duration = parseFloat(match[1]);
|
|
}
|
|
if (match[2]) {
|
|
event.title = match[2];
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-TARGETDURATION:?([0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'targetduration'
|
|
};
|
|
if (match[1]) {
|
|
event.duration = parseInt(match[1], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#ZEN-TOTAL-DURATION:?([0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'totalduration'
|
|
};
|
|
if (match[1]) {
|
|
event.duration = parseInt(match[1], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-VERSION:?([0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'version'
|
|
};
|
|
if (match[1]) {
|
|
event.version = parseInt(match[1], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-MEDIA-SEQUENCE:?(\-?[0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'media-sequence'
|
|
};
|
|
if (match[1]) {
|
|
event.number = parseInt(match[1], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-DISCONTINUITY-SEQUENCE:?(\-?[0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'discontinuity-sequence'
|
|
};
|
|
if (match[1]) {
|
|
event.number = parseInt(match[1], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-PLAYLIST-TYPE:?(.*)?$/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'playlist-type'
|
|
};
|
|
if (match[1]) {
|
|
event.playlistType = match[1];
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-BYTERANGE:?([0-9.]*)?@?([0-9.]*)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'byterange'
|
|
};
|
|
if (match[1]) {
|
|
event.length = parseInt(match[1], 10);
|
|
}
|
|
if (match[2]) {
|
|
event.offset = parseInt(match[2], 10);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-ALLOW-CACHE:?(YES|NO)?/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'allow-cache'
|
|
};
|
|
if (match[1]) {
|
|
event.allowed = !/NO/.test(match[1]);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-STREAM-INF:?(.*)$/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'stream-inf'
|
|
};
|
|
if (match[1]) {
|
|
event.attributes = parseAttributes(match[1]);
|
|
|
|
if (event.attributes.RESOLUTION) {
|
|
var split = event.attributes.RESOLUTION.split('x');
|
|
var resolution = {};
|
|
|
|
if (split[0]) {
|
|
resolution.width = parseInt(split[0], 10);
|
|
}
|
|
if (split[1]) {
|
|
resolution.height = parseInt(split[1], 10);
|
|
}
|
|
event.attributes.RESOLUTION = resolution;
|
|
}
|
|
if (event.attributes.BANDWIDTH) {
|
|
event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
|
|
}
|
|
if (event.attributes['PROGRAM-ID']) {
|
|
event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);
|
|
}
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-MEDIA:?(.*)$/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'media'
|
|
};
|
|
if (match[1]) {
|
|
event.attributes = parseAttributes(match[1]);
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
match = /^#EXT-X-ENDLIST/.exec(line);
|
|
if (match) {
|
|
this.trigger('data', {
|
|
type: 'tag',
|
|
tagType: 'endlist'
|
|
});
|
|
return;
|
|
}
|
|
match = /^#EXT-X-DISCONTINUITY/.exec(line);
|
|
if (match) {
|
|
this.trigger('data', {
|
|
type: 'tag',
|
|
tagType: 'discontinuity'
|
|
});
|
|
return;
|
|
}
|
|
match = /^#EXT-X-KEY:?(.*)$/.exec(line);
|
|
if (match) {
|
|
event = {
|
|
type: 'tag',
|
|
tagType: 'key'
|
|
};
|
|
if (match[1]) {
|
|
event.attributes = parseAttributes(match[1]);
|
|
// parse the IV string into a Uint32Array
|
|
if (event.attributes.IV) {
|
|
if (event.attributes.IV.substring(0, 2).toLowerCase() === '0x') {
|
|
event.attributes.IV = event.attributes.IV.substring(2);
|
|
}
|
|
|
|
event.attributes.IV = event.attributes.IV.match(/.{8}/g);
|
|
event.attributes.IV[0] = parseInt(event.attributes.IV[0], 16);
|
|
event.attributes.IV[1] = parseInt(event.attributes.IV[1], 16);
|
|
event.attributes.IV[2] = parseInt(event.attributes.IV[2], 16);
|
|
event.attributes.IV[3] = parseInt(event.attributes.IV[3], 16);
|
|
event.attributes.IV = new Uint32Array(event.attributes.IV);
|
|
}
|
|
}
|
|
this.trigger('data', event);
|
|
return;
|
|
}
|
|
|
|
// unknown tag type
|
|
this.trigger('data', {
|
|
type: 'tag',
|
|
data: line.slice(4, line.length)
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return ParseStream;
|
|
})(_stream2['default']);
|
|
|
|
exports['default'] = ParseStream;
|
|
module.exports = exports['default'];
|
|
},{"../stream":18}],10:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file m3u8/parser.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _stream = require('../stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
var _lineStream = require('./line-stream');
|
|
|
|
var _lineStream2 = _interopRequireDefault(_lineStream);
|
|
|
|
var _parseStream = require('./parse-stream');
|
|
|
|
var _parseStream2 = _interopRequireDefault(_parseStream);
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
/**
|
|
* A parser for M3U8 files. The current interpretation of the input is
|
|
* exposed as a property `manifest` on parser objects. It's just two lines to
|
|
* create and parse a manifest once you have the contents available as a string:
|
|
*
|
|
* ```js
|
|
* var parser = new videojs.m3u8.Parser();
|
|
* parser.push(xhr.responseText);
|
|
* ```
|
|
*
|
|
* New input can later be applied to update the manifest object by calling
|
|
* `push` again.
|
|
*
|
|
* The parser attempts to create a usable manifest object even if the
|
|
* underlying input is somewhat nonsensical. It emits `info` and `warning`
|
|
* events during the parse if it encounters input that seems invalid or
|
|
* requires some property of the manifest object to be defaulted.
|
|
*
|
|
* @class Parser
|
|
* @extends Stream
|
|
*/
|
|
|
|
var Parser = (function (_Stream) {
|
|
_inherits(Parser, _Stream);
|
|
|
|
function Parser() {
|
|
_classCallCheck(this, Parser);
|
|
|
|
_get(Object.getPrototypeOf(Parser.prototype), 'constructor', this).call(this);
|
|
this.lineStream = new _lineStream2['default']();
|
|
this.parseStream = new _parseStream2['default']();
|
|
this.lineStream.pipe(this.parseStream);
|
|
/* eslint-disable consistent-this */
|
|
var self = this;
|
|
/* eslint-enable consistent-this */
|
|
var uris = [];
|
|
var currentUri = {};
|
|
var _key = undefined;
|
|
var noop = function noop() {};
|
|
var defaultMediaGroups = {
|
|
'AUDIO': {},
|
|
'VIDEO': {},
|
|
'CLOSED-CAPTIONS': {},
|
|
'SUBTITLES': {}
|
|
};
|
|
// group segments into numbered timelines delineated by discontinuities
|
|
var currentTimeline = 0;
|
|
|
|
// the manifest is empty until the parse stream begins delivering data
|
|
this.manifest = {
|
|
allowCache: true,
|
|
discontinuityStarts: []
|
|
};
|
|
|
|
// update the manifest with the m3u8 entry from the parse stream
|
|
this.parseStream.on('data', function (entry) {
|
|
var mediaGroup = undefined;
|
|
var rendition = undefined;
|
|
|
|
({
|
|
tag: function tag() {
|
|
// switch based on the tag type
|
|
(({
|
|
'allow-cache': function allowCache() {
|
|
this.manifest.allowCache = entry.allowed;
|
|
if (!('allowed' in entry)) {
|
|
this.trigger('info', {
|
|
message: 'defaulting allowCache to YES'
|
|
});
|
|
this.manifest.allowCache = true;
|
|
}
|
|
},
|
|
byterange: function byterange() {
|
|
var byterange = {};
|
|
|
|
if ('length' in entry) {
|
|
currentUri.byterange = byterange;
|
|
byterange.length = entry.length;
|
|
|
|
if (!('offset' in entry)) {
|
|
this.trigger('info', {
|
|
message: 'defaulting offset to zero'
|
|
});
|
|
entry.offset = 0;
|
|
}
|
|
}
|
|
if ('offset' in entry) {
|
|
currentUri.byterange = byterange;
|
|
byterange.offset = entry.offset;
|
|
}
|
|
},
|
|
endlist: function endlist() {
|
|
this.manifest.endList = true;
|
|
},
|
|
inf: function inf() {
|
|
if (!('mediaSequence' in this.manifest)) {
|
|
this.manifest.mediaSequence = 0;
|
|
this.trigger('info', {
|
|
message: 'defaulting media sequence to zero'
|
|
});
|
|
}
|
|
if (!('discontinuitySequence' in this.manifest)) {
|
|
this.manifest.discontinuitySequence = 0;
|
|
this.trigger('info', {
|
|
message: 'defaulting discontinuity sequence to zero'
|
|
});
|
|
}
|
|
if (entry.duration >= 0) {
|
|
currentUri.duration = entry.duration;
|
|
}
|
|
|
|
this.manifest.segments = uris;
|
|
},
|
|
key: function key() {
|
|
if (!entry.attributes) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring key declaration without attribute list'
|
|
});
|
|
return;
|
|
}
|
|
// clear the active encryption key
|
|
if (entry.attributes.METHOD === 'NONE') {
|
|
_key = null;
|
|
return;
|
|
}
|
|
if (!entry.attributes.URI) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring key declaration without URI'
|
|
});
|
|
return;
|
|
}
|
|
if (!entry.attributes.METHOD) {
|
|
this.trigger('warn', {
|
|
message: 'defaulting key method to AES-128'
|
|
});
|
|
}
|
|
|
|
// setup an encryption key for upcoming segments
|
|
_key = {
|
|
method: entry.attributes.METHOD || 'AES-128',
|
|
uri: entry.attributes.URI
|
|
};
|
|
|
|
if (typeof entry.attributes.IV !== 'undefined') {
|
|
_key.iv = entry.attributes.IV;
|
|
}
|
|
},
|
|
'media-sequence': function mediaSequence() {
|
|
if (!isFinite(entry.number)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid media sequence: ' + entry.number
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.mediaSequence = entry.number;
|
|
},
|
|
'discontinuity-sequence': function discontinuitySequence() {
|
|
if (!isFinite(entry.number)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid discontinuity sequence: ' + entry.number
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.discontinuitySequence = entry.number;
|
|
currentTimeline = entry.number;
|
|
},
|
|
'playlist-type': function playlistType() {
|
|
if (!/VOD|EVENT/.test(entry.playlistType)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring unknown playlist type: ' + entry.playlist
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.playlistType = entry.playlistType;
|
|
},
|
|
'stream-inf': function streamInf() {
|
|
this.manifest.playlists = uris;
|
|
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
|
|
|
|
if (!entry.attributes) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring empty stream-inf attributes'
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!currentUri.attributes) {
|
|
currentUri.attributes = {};
|
|
}
|
|
currentUri.attributes = (0, _videoJs.mergeOptions)(currentUri.attributes, entry.attributes);
|
|
},
|
|
media: function media() {
|
|
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
|
|
|
|
if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring incomplete or missing media group'
|
|
});
|
|
return;
|
|
}
|
|
|
|
// find the media group, creating defaults as necessary
|
|
var mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
|
|
|
|
mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};
|
|
mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']];
|
|
|
|
// collect the rendition metadata
|
|
rendition = {
|
|
'default': /yes/i.test(entry.attributes.DEFAULT)
|
|
};
|
|
if (rendition['default']) {
|
|
rendition.autoselect = true;
|
|
} else {
|
|
rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);
|
|
}
|
|
if (entry.attributes.LANGUAGE) {
|
|
rendition.language = entry.attributes.LANGUAGE;
|
|
}
|
|
if (entry.attributes.URI) {
|
|
rendition.uri = entry.attributes.URI;
|
|
}
|
|
|
|
// insert the new rendition
|
|
mediaGroup[entry.attributes.NAME] = rendition;
|
|
},
|
|
discontinuity: function discontinuity() {
|
|
currentTimeline += 1;
|
|
currentUri.discontinuity = true;
|
|
this.manifest.discontinuityStarts.push(uris.length);
|
|
},
|
|
targetduration: function targetduration() {
|
|
if (!isFinite(entry.duration) || entry.duration < 0) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid target duration: ' + entry.duration
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.targetDuration = entry.duration;
|
|
},
|
|
totalduration: function totalduration() {
|
|
if (!isFinite(entry.duration) || entry.duration < 0) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid total duration: ' + entry.duration
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.totalDuration = entry.duration;
|
|
}
|
|
})[entry.tagType] || noop).call(self);
|
|
},
|
|
uri: function uri() {
|
|
currentUri.uri = entry.uri;
|
|
uris.push(currentUri);
|
|
|
|
// if no explicit duration was declared, use the target duration
|
|
if (this.manifest.targetDuration && !('duration' in currentUri)) {
|
|
this.trigger('warn', {
|
|
message: 'defaulting segment duration to the target duration'
|
|
});
|
|
currentUri.duration = this.manifest.targetDuration;
|
|
}
|
|
// annotate with encryption information, if necessary
|
|
if (_key) {
|
|
currentUri.key = _key;
|
|
}
|
|
currentUri.timeline = currentTimeline;
|
|
|
|
// prepare for the next URI
|
|
currentUri = {};
|
|
},
|
|
comment: function comment() {
|
|
// comments are not important for playback
|
|
}
|
|
})[entry.type].call(self);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Parse the input string and update the manifest object.
|
|
*
|
|
* @param {String} chunk a potentially incomplete portion of the manifest
|
|
*/
|
|
|
|
_createClass(Parser, [{
|
|
key: 'push',
|
|
value: function push(chunk) {
|
|
this.lineStream.push(chunk);
|
|
}
|
|
|
|
/**
|
|
* Flush any remaining input. This can be handy if the last line of an M3U8
|
|
* manifest did not contain a trailing newline but the file has been
|
|
* completely received.
|
|
*/
|
|
}, {
|
|
key: 'end',
|
|
value: function end() {
|
|
// flush any buffered input
|
|
this.lineStream.push('\n');
|
|
}
|
|
}]);
|
|
|
|
return Parser;
|
|
})(_stream2['default']);
|
|
|
|
exports['default'] = Parser;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"../stream":18,"./line-stream":8,"./parse-stream":9}],11:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file master-playlist-controller.js
|
|
*/
|
|
'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 _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _playlistLoader = require('./playlist-loader');
|
|
|
|
var _playlistLoader2 = _interopRequireDefault(_playlistLoader);
|
|
|
|
var _segmentLoader = require('./segment-loader');
|
|
|
|
var _segmentLoader2 = _interopRequireDefault(_segmentLoader);
|
|
|
|
var _ranges = require('./ranges');
|
|
|
|
var _ranges2 = _interopRequireDefault(_ranges);
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _hlsAudioTrack = require('./hls-audio-track');
|
|
|
|
var _hlsAudioTrack2 = _interopRequireDefault(_hlsAudioTrack);
|
|
|
|
// 5 minute blacklist
|
|
var BLACKLIST_DURATION = 5 * 60 * 1000;
|
|
var Hls = undefined;
|
|
|
|
var parseCodecs = function parseCodecs(codecs) {
|
|
var result = {
|
|
codecCount: 0,
|
|
videoCodec: null,
|
|
audioProfile: null
|
|
};
|
|
|
|
result.codecCount = codecs.split(',').length;
|
|
result.codecCount = result.codecCount || 2;
|
|
|
|
// parse the video codec but ignore the version
|
|
result.videoCodec = /(^|\s|,)+(avc1)[^ ,]*/i.exec(codecs);
|
|
result.videoCodec = result.videoCodec && result.videoCodec[2];
|
|
|
|
// parse the last field of the audio codec
|
|
result.audioProfile = /(^|\s|,)+mp4a.\d+\.(\d+)/i.exec(codecs);
|
|
result.audioProfile = result.audioProfile && result.audioProfile[2];
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* the master playlist controller controller all interactons
|
|
* between playlists and segmentloaders. At this time this mainly
|
|
* involves a master playlist and a series of audio playlists
|
|
* if they are available
|
|
*
|
|
* @class MasterPlaylistController
|
|
* @extends videojs.EventTarget
|
|
*/
|
|
|
|
var MasterPlaylistController = (function (_videojs$EventTarget) {
|
|
_inherits(MasterPlaylistController, _videojs$EventTarget);
|
|
|
|
function MasterPlaylistController(_ref) {
|
|
var _this = this;
|
|
|
|
var url = _ref.url;
|
|
var withCredentials = _ref.withCredentials;
|
|
var mode = _ref.mode;
|
|
var tech = _ref.tech;
|
|
var bandwidth = _ref.bandwidth;
|
|
var externHls = _ref.externHls;
|
|
|
|
_classCallCheck(this, MasterPlaylistController);
|
|
|
|
_get(Object.getPrototypeOf(MasterPlaylistController.prototype), 'constructor', this).call(this);
|
|
|
|
Hls = externHls;
|
|
|
|
this.withCredentials = withCredentials;
|
|
this.tech_ = tech;
|
|
this.hls_ = tech.hls;
|
|
this.mode_ = mode;
|
|
this.audioTracks_ = [];
|
|
|
|
this.mediaSource = new _videoJs2['default'].MediaSource({ mode: mode });
|
|
this.mediaSource.on('audioinfo', function (e) {
|
|
return _this.trigger(e);
|
|
});
|
|
// load the media source into the player
|
|
this.mediaSource.addEventListener('sourceopen', this.handleSourceOpen_.bind(this));
|
|
|
|
var segmentLoaderOptions = {
|
|
hls: this.hls_,
|
|
mediaSource: this.mediaSource,
|
|
currentTime: this.tech_.currentTime.bind(this.tech_),
|
|
withCredentials: this.withCredentials,
|
|
seekable: function seekable() {
|
|
return _this.seekable();
|
|
},
|
|
seeking: function seeking() {
|
|
return _this.tech_.seeking();
|
|
},
|
|
setCurrentTime: function setCurrentTime(a) {
|
|
return _this.setCurrentTime(a);
|
|
},
|
|
hasPlayed: function hasPlayed() {
|
|
return _this.tech_.played().length !== 0;
|
|
},
|
|
bandwidth: bandwidth
|
|
};
|
|
|
|
// combined audio/video or just video when alternate audio track is selected
|
|
this.mainSegmentLoader_ = new _segmentLoader2['default'](segmentLoaderOptions);
|
|
// alternate audio track
|
|
this.audioSegmentLoader_ = new _segmentLoader2['default'](segmentLoaderOptions);
|
|
|
|
if (!url) {
|
|
throw new Error('A non-empty playlist URL is required');
|
|
}
|
|
|
|
this.masterPlaylistLoader_ = new _playlistLoader2['default'](url, this.hls_, this.withCredentials);
|
|
|
|
this.masterPlaylistLoader_.on('loadedmetadata', function () {
|
|
var media = _this.masterPlaylistLoader_.media();
|
|
|
|
// if this isn't a live video and preload permits, start
|
|
// downloading segments
|
|
if (media.endList && _this.tech_.preload() !== 'none') {
|
|
_this.mainSegmentLoader_.playlist(media);
|
|
_this.mainSegmentLoader_.expired(_this.masterPlaylistLoader_.expired_);
|
|
_this.mainSegmentLoader_.load();
|
|
}
|
|
|
|
_this.setupSourceBuffer_();
|
|
_this.setupFirstPlay();
|
|
_this.useAudio();
|
|
});
|
|
|
|
this.masterPlaylistLoader_.on('loadedplaylist', function () {
|
|
var updatedPlaylist = _this.masterPlaylistLoader_.media();
|
|
var seekable = undefined;
|
|
|
|
if (!updatedPlaylist) {
|
|
// select the initial variant
|
|
_this.initialMedia_ = _this.selectPlaylist();
|
|
_this.masterPlaylistLoader_.media(_this.initialMedia_);
|
|
_this.fillAudioTracks_();
|
|
|
|
_this.trigger('selectedinitialmedia');
|
|
return;
|
|
}
|
|
|
|
_this.mainSegmentLoader_.playlist(updatedPlaylist);
|
|
_this.mainSegmentLoader_.expired(_this.masterPlaylistLoader_.expired_);
|
|
_this.updateDuration();
|
|
|
|
// update seekable
|
|
seekable = _this.seekable();
|
|
if (!updatedPlaylist.endList && seekable.length !== 0) {
|
|
_this.mediaSource.addSeekableRange_(seekable.start(0), seekable.end(0));
|
|
}
|
|
});
|
|
|
|
this.masterPlaylistLoader_.on('error', function () {
|
|
_this.blacklistCurrentPlaylist(_this.masterPlaylistLoader_.error);
|
|
});
|
|
|
|
this.masterPlaylistLoader_.on('mediachanging', function () {
|
|
_this.mainSegmentLoader_.pause();
|
|
});
|
|
|
|
this.masterPlaylistLoader_.on('mediachange', function () {
|
|
_this.mainSegmentLoader_.abort();
|
|
_this.mainSegmentLoader_.load();
|
|
_this.tech_.trigger({
|
|
type: 'mediachange',
|
|
bubbles: true
|
|
});
|
|
});
|
|
|
|
this.mainSegmentLoader_.on('progress', function () {
|
|
// figure out what stream the next segment should be downloaded from
|
|
// with the updated bandwidth information
|
|
_this.masterPlaylistLoader_.media(_this.selectPlaylist());
|
|
|
|
_this.trigger('progress');
|
|
});
|
|
|
|
this.mainSegmentLoader_.on('error', function () {
|
|
_this.blacklistCurrentPlaylist(_this.mainSegmentLoader_.error());
|
|
});
|
|
|
|
this.audioSegmentLoader_.on('error', function () {
|
|
_videoJs2['default'].log.warn('Problem encountered with the current alternate audio track' + '. Switching back to default.');
|
|
_this.audioSegmentLoader_.abort();
|
|
_this.audioPlaylistLoader_ = null;
|
|
_this.useAudio();
|
|
});
|
|
|
|
this.masterPlaylistLoader_.load();
|
|
}
|
|
|
|
/**
|
|
* fill our internal list of HlsAudioTracks with data from
|
|
* the master playlist or use a default
|
|
*
|
|
* @private
|
|
*/
|
|
|
|
_createClass(MasterPlaylistController, [{
|
|
key: 'fillAudioTracks_',
|
|
value: function fillAudioTracks_() {
|
|
var master = this.master();
|
|
var mediaGroups = master.mediaGroups || {};
|
|
|
|
// force a default if we have none or we are not
|
|
// in html5 mode (the only mode to support more than one
|
|
// audio track)
|
|
if (!mediaGroups || !mediaGroups.AUDIO || Object.keys(mediaGroups.AUDIO).length === 0 || this.mode_ !== 'html5') {
|
|
// "main" audio group, track name "default"
|
|
mediaGroups.AUDIO = { main: { 'default': { 'default': true } } };
|
|
}
|
|
|
|
var tracks = {};
|
|
|
|
for (var mediaGroup in mediaGroups.AUDIO) {
|
|
for (var label in mediaGroups.AUDIO[mediaGroup]) {
|
|
var properties = mediaGroups.AUDIO[mediaGroup][label];
|
|
|
|
// if the track already exists add a new "location"
|
|
// since tracks in different mediaGroups are actually the same
|
|
// track with different locations to download them from
|
|
if (tracks[label]) {
|
|
tracks[label].addLoader(mediaGroup, properties.resolvedUri);
|
|
continue;
|
|
}
|
|
|
|
var track = new _hlsAudioTrack2['default'](_videoJs2['default'].mergeOptions(properties, {
|
|
hls: this.hls_,
|
|
withCredentials: this.withCredential,
|
|
mediaGroup: mediaGroup,
|
|
label: label
|
|
}));
|
|
|
|
tracks[label] = track;
|
|
this.audioTracks_.push(track);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call load on our SegmentLoaders
|
|
*/
|
|
}, {
|
|
key: 'load',
|
|
value: function load() {
|
|
this.mainSegmentLoader_.load();
|
|
if (this.audioPlaylistLoader_) {
|
|
this.audioSegmentLoader_.load();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the current active Media Group for Audio
|
|
* given the selected playlist and its attributes
|
|
*/
|
|
}, {
|
|
key: 'activeAudioGroup',
|
|
value: function activeAudioGroup() {
|
|
var media = this.masterPlaylistLoader_.media();
|
|
var mediaGroup = 'main';
|
|
|
|
if (media && media.attributes && media.attributes.AUDIO) {
|
|
mediaGroup = media.attributes.AUDIO;
|
|
}
|
|
|
|
return mediaGroup;
|
|
}
|
|
|
|
/**
|
|
* Use any audio track that we have, and start to load it
|
|
*/
|
|
}, {
|
|
key: 'useAudio',
|
|
value: function useAudio() {
|
|
var _this2 = this;
|
|
|
|
var track = undefined;
|
|
|
|
this.audioTracks_.forEach(function (t) {
|
|
if (!track && t.enabled) {
|
|
track = t;
|
|
}
|
|
});
|
|
|
|
// called too early or no track is enabled
|
|
if (!track) {
|
|
return;
|
|
}
|
|
|
|
// Pause any alternative audio
|
|
if (this.audioPlaylistLoader_) {
|
|
this.audioPlaylistLoader_.pause();
|
|
this.audioPlaylistLoader_ = null;
|
|
this.audioSegmentLoader_.pause();
|
|
}
|
|
|
|
// If the audio track for the active audio group has
|
|
// a playlist loader than it is an alterative audio track
|
|
// otherwise it is a part of the mainSegmenLoader
|
|
var loader = track.getLoader(this.activeAudioGroup());
|
|
|
|
if (!loader) {
|
|
this.mainSegmentLoader_.clearBuffer();
|
|
return;
|
|
}
|
|
|
|
// TODO: it may be better to create the playlist loader here
|
|
// when we can change an audioPlaylistLoaders src
|
|
this.audioPlaylistLoader_ = loader;
|
|
|
|
if (this.audioPlaylistLoader_.started) {
|
|
this.audioPlaylistLoader_.load();
|
|
this.audioSegmentLoader_.load();
|
|
this.audioSegmentLoader_.clearBuffer();
|
|
return;
|
|
}
|
|
|
|
this.audioPlaylistLoader_.on('loadedmetadata', function () {
|
|
/* eslint-disable no-shadow */
|
|
var media = _this2.audioPlaylistLoader_.media();
|
|
/* eslint-enable no-shadow */
|
|
|
|
_this2.audioSegmentLoader_.playlist(media);
|
|
_this2.addMimeType_(_this2.audioSegmentLoader_, 'mp4a.40.2', media);
|
|
|
|
// if the video is already playing, or if this isn't a live video and preload
|
|
// permits, start downloading segments
|
|
if (!_this2.tech_.paused() || media.endList && _this2.tech_.preload() !== 'none') {
|
|
_this2.audioSegmentLoader_.load();
|
|
}
|
|
|
|
if (!media.endList) {
|
|
// trigger the playlist loader to start "expired time"-tracking
|
|
_this2.audioPlaylistLoader_.trigger('firstplay');
|
|
}
|
|
});
|
|
|
|
this.audioPlaylistLoader_.on('loadedplaylist', function () {
|
|
var updatedPlaylist = undefined;
|
|
|
|
if (_this2.audioPlaylistLoader_) {
|
|
updatedPlaylist = _this2.audioPlaylistLoader_.media();
|
|
}
|
|
|
|
if (!updatedPlaylist) {
|
|
// only one playlist to select
|
|
_this2.audioPlaylistLoader_.media(_this2.audioPlaylistLoader_.playlists.master.playlists[0]);
|
|
return;
|
|
}
|
|
|
|
_this2.audioSegmentLoader_.playlist(updatedPlaylist);
|
|
});
|
|
|
|
this.audioPlaylistLoader_.on('error', function () {
|
|
_videoJs2['default'].log.warn('Problem encountered loading the alternate audio track' + '. Switching back to default.');
|
|
_this2.audioSegmentLoader_.abort();
|
|
_this2.audioPlaylistLoader_ = null;
|
|
_this2.useAudio();
|
|
});
|
|
|
|
this.audioSegmentLoader_.clearBuffer();
|
|
this.audioPlaylistLoader_.start();
|
|
}
|
|
|
|
/**
|
|
* Re-tune playback quality level for the current player
|
|
* conditions. This method may perform destructive actions, like
|
|
* removing already buffered content, to readjust the currently
|
|
* active playlist quickly.
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'fastQualityChange_',
|
|
value: function fastQualityChange_() {
|
|
var media = this.selectPlaylist();
|
|
|
|
if (media !== this.masterPlaylistLoader_.media()) {
|
|
this.masterPlaylistLoader_.media(media);
|
|
this.mainSegmentLoader_.sourceUpdater_.remove(this.tech_.currentTime() + 5, Infinity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Begin playback.
|
|
*/
|
|
}, {
|
|
key: 'play',
|
|
value: function play() {
|
|
if (this.setupFirstPlay()) {
|
|
return;
|
|
}
|
|
|
|
if (this.tech_.ended()) {
|
|
this.tech_.setCurrentTime(0);
|
|
}
|
|
|
|
this.load();
|
|
|
|
// if the viewer has paused and we fell out of the live window,
|
|
// seek forward to the earliest available position
|
|
if (this.tech_.duration() === Infinity) {
|
|
if (this.tech_.currentTime() < this.tech_.seekable().start(0)) {
|
|
return this.tech_.setCurrentTime(this.tech_.seekable().start(0));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Seek to the latest media position if this is a live video and the
|
|
* player and video are loaded and initialized.
|
|
*/
|
|
}, {
|
|
key: 'setupFirstPlay',
|
|
value: function setupFirstPlay() {
|
|
var seekable = undefined;
|
|
var media = this.masterPlaylistLoader_.media();
|
|
|
|
// check that everything is ready to begin buffering
|
|
// 1) the active media playlist is available
|
|
if (media &&
|
|
// 2) the video is a live stream
|
|
!media.endList &&
|
|
|
|
// 3) the player is not paused
|
|
!this.tech_.paused() &&
|
|
|
|
// 4) the player has not started playing
|
|
!this.hasPlayed_) {
|
|
|
|
this.load();
|
|
|
|
// trigger the playlist loader to start "expired time"-tracking
|
|
this.masterPlaylistLoader_.trigger('firstplay');
|
|
this.hasPlayed_ = true;
|
|
|
|
// seek to the latest media position for live videos
|
|
seekable = this.seekable();
|
|
if (seekable.length) {
|
|
this.tech_.setCurrentTime(seekable.end(0));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* handle the sourceopen event on the MediaSource
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'handleSourceOpen_',
|
|
value: function handleSourceOpen_() {
|
|
// Only attempt to create the source buffer if none already exist.
|
|
// handleSourceOpen is also called when we are "re-opening" a source buffer
|
|
// after `endOfStream` has been called (in response to a seek for instance)
|
|
this.setupSourceBuffer_();
|
|
|
|
// if autoplay is enabled, begin playback. This is duplicative of
|
|
// code in video.js but is required because play() must be invoked
|
|
// *after* the media source has opened.
|
|
if (this.tech_.autoplay()) {
|
|
this.tech_.play();
|
|
}
|
|
|
|
this.trigger('sourceopen');
|
|
}
|
|
|
|
/**
|
|
* Blacklists a playlist when an error occurs for a set amount of time
|
|
* making it unavailable for selection by the rendition selection algorithm
|
|
* and then forces a new playlist (rendition) selection.
|
|
*
|
|
* @param {Object=} error an optional error that may include the playlist
|
|
* to blacklist
|
|
*/
|
|
}, {
|
|
key: 'blacklistCurrentPlaylist',
|
|
value: function blacklistCurrentPlaylist() {
|
|
var error = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
|
|
|
var currentPlaylist = undefined;
|
|
var nextPlaylist = undefined;
|
|
|
|
// If the `error` was generated by the playlist loader, it will contain
|
|
// the playlist we were trying to load (but failed) and that should be
|
|
// blacklisted instead of the currently selected playlist which is likely
|
|
// out-of-date in this scenario
|
|
currentPlaylist = error.playlist || this.masterPlaylistLoader_.media();
|
|
|
|
// If there is no current playlist, then an error occurred while we were
|
|
// trying to load the master OR while we were disposing of the tech
|
|
if (!currentPlaylist) {
|
|
this.error = error;
|
|
return this.mediaSource.endOfStream('network');
|
|
}
|
|
|
|
// Blacklist this playlist
|
|
currentPlaylist.excludeUntil = Date.now() + BLACKLIST_DURATION;
|
|
|
|
// Select a new playlist
|
|
nextPlaylist = this.selectPlaylist();
|
|
|
|
if (nextPlaylist) {
|
|
_videoJs2['default'].log.warn('Problem encountered with the current ' + 'HLS playlist. Switching to another playlist.');
|
|
|
|
return this.masterPlaylistLoader_.media(nextPlaylist);
|
|
}
|
|
_videoJs2['default'].log.warn('Problem encountered with the current ' + 'HLS playlist. No suitable alternatives found.');
|
|
// We have no more playlists we can select so we must fail
|
|
this.error = error;
|
|
return this.mediaSource.endOfStream('network');
|
|
}
|
|
|
|
/**
|
|
* Pause all segment loaders
|
|
*/
|
|
}, {
|
|
key: 'pauseLoading',
|
|
value: function pauseLoading() {
|
|
this.mainSegmentLoader_.pause();
|
|
if (this.audioPlaylistLoader_) {
|
|
this.audioSegmentLoader_.pause();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set the current time on all segment loaders
|
|
*
|
|
* @param {TimeRange} currentTime the current time to set
|
|
* @return {TimeRange} the current time
|
|
*/
|
|
}, {
|
|
key: 'setCurrentTime',
|
|
value: function setCurrentTime(currentTime) {
|
|
var buffered = _ranges2['default'].findRange(this.tech_.buffered(), currentTime);
|
|
|
|
if (!(this.masterPlaylistLoader_ && this.masterPlaylistLoader_.media())) {
|
|
// return immediately if the metadata is not ready yet
|
|
return 0;
|
|
}
|
|
|
|
// it's clearly an edge-case but don't thrown an error if asked to
|
|
// seek within an empty playlist
|
|
if (!this.masterPlaylistLoader_.media().segments) {
|
|
return 0;
|
|
}
|
|
|
|
// if the seek location is already buffered, continue buffering as
|
|
// usual
|
|
if (buffered && buffered.length) {
|
|
return currentTime;
|
|
}
|
|
|
|
// cancel outstanding requests so we begin buffering at the new
|
|
// location
|
|
this.mainSegmentLoader_.abort();
|
|
if (this.audioPlaylistLoader_) {
|
|
this.audioSegmentLoader_.abort();
|
|
}
|
|
|
|
if (!this.tech_.paused()) {
|
|
this.mainSegmentLoader_.load();
|
|
if (this.audioPlaylistLoader_) {
|
|
this.audioSegmentLoader_.load();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get the current duration
|
|
*
|
|
* @return {TimeRange} the duration
|
|
*/
|
|
}, {
|
|
key: 'duration',
|
|
value: function duration() {
|
|
if (!this.masterPlaylistLoader_) {
|
|
return 0;
|
|
}
|
|
|
|
if (this.mediaSource) {
|
|
return this.mediaSource.duration;
|
|
}
|
|
|
|
return Hls.Playlist.duration(this.masterPlaylistLoader_.media());
|
|
}
|
|
|
|
/**
|
|
* check the seekable range
|
|
*
|
|
* @return {TimeRange} the seekable range
|
|
*/
|
|
}, {
|
|
key: 'seekable',
|
|
value: function seekable() {
|
|
var media = undefined;
|
|
var mainSeekable = undefined;
|
|
var audioSeekable = undefined;
|
|
|
|
if (!this.masterPlaylistLoader_) {
|
|
return _videoJs2['default'].createTimeRanges();
|
|
}
|
|
media = this.masterPlaylistLoader_.media();
|
|
if (!media) {
|
|
return _videoJs2['default'].createTimeRanges();
|
|
}
|
|
|
|
mainSeekable = Hls.Playlist.seekable(media, this.masterPlaylistLoader_.expired_);
|
|
if (mainSeekable.length === 0) {
|
|
return mainSeekable;
|
|
}
|
|
|
|
if (this.audioPlaylistLoader_) {
|
|
audioSeekable = Hls.Playlist.seekable(this.audioPlaylistLoader_.media(), this.audioPlaylistLoader_.expired_);
|
|
if (audioSeekable.length === 0) {
|
|
return audioSeekable;
|
|
}
|
|
}
|
|
|
|
if (!audioSeekable) {
|
|
// seekable has been calculated based on buffering video data so it
|
|
// can be returned directly
|
|
return mainSeekable;
|
|
}
|
|
|
|
return _videoJs2['default'].createTimeRanges([[audioSeekable.start(0) > mainSeekable.start(0) ? audioSeekable.start(0) : mainSeekable.start(0), audioSeekable.end(0) < mainSeekable.end(0) ? audioSeekable.end(0) : mainSeekable.end(0)]]);
|
|
}
|
|
|
|
/**
|
|
* Update the player duration
|
|
*/
|
|
}, {
|
|
key: 'updateDuration',
|
|
value: function updateDuration() {
|
|
var _this3 = this;
|
|
|
|
var oldDuration = this.mediaSource.duration;
|
|
var newDuration = Hls.Playlist.duration(this.masterPlaylistLoader_.media());
|
|
var buffered = this.tech_.buffered();
|
|
var setDuration = function setDuration() {
|
|
_this3.mediaSource.duration = newDuration;
|
|
_this3.tech_.trigger('durationchange');
|
|
|
|
_this3.mediaSource.removeEventListener('sourceopen', setDuration);
|
|
};
|
|
|
|
if (buffered.length > 0) {
|
|
newDuration = Math.max(newDuration, buffered.end(buffered.length - 1));
|
|
}
|
|
|
|
// if the duration has changed, invalidate the cached value
|
|
if (oldDuration !== newDuration) {
|
|
// update the duration
|
|
if (this.mediaSource.readyState !== 'open') {
|
|
this.mediaSource.addEventListener('sourceopen', setDuration);
|
|
} else {
|
|
setDuration();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dispose of the MasterPlaylistController and everything
|
|
* that it controls
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
this.masterPlaylistLoader_.dispose();
|
|
this.audioTracks_.forEach(function (track) {
|
|
track.dispose();
|
|
});
|
|
this.audioTracks_.length = 0;
|
|
this.mainSegmentLoader_.dispose();
|
|
this.audioSegmentLoader_.dispose();
|
|
}
|
|
|
|
/**
|
|
* return the master playlist object if we have one
|
|
*
|
|
* @return {Object} the master playlist object that we parsed
|
|
*/
|
|
}, {
|
|
key: 'master',
|
|
value: function master() {
|
|
return this.masterPlaylistLoader_.master;
|
|
}
|
|
|
|
/**
|
|
* return the currently selected playlist
|
|
*
|
|
* @return {Object} the currently selected playlist object that we parsed
|
|
*/
|
|
}, {
|
|
key: 'media',
|
|
value: function media() {
|
|
// playlist loader will not return media if it has not been fully loaded
|
|
return this.masterPlaylistLoader_.media() || this.initialMedia_;
|
|
}
|
|
|
|
/**
|
|
* setup our internal source buffers on our segment Loaders
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'setupSourceBuffer_',
|
|
value: function setupSourceBuffer_() {
|
|
var media = this.masterPlaylistLoader_.media();
|
|
|
|
// wait until a media playlist is available and the Media Source is
|
|
// attached
|
|
if (!media || this.mediaSource.readyState !== 'open') {
|
|
return;
|
|
}
|
|
|
|
this.addMimeType_(this.mainSegmentLoader_, 'avc1.4d400d, mp4a.40.2', media);
|
|
|
|
// exclude any incompatible variant streams from future playlist
|
|
// selection
|
|
this.excludeIncompatibleVariants_(media);
|
|
}
|
|
|
|
/**
|
|
* add a time type to a segmentLoader
|
|
*
|
|
* @param {SegmentLoader} segmentLoader the segmentloader to work on
|
|
* @param {String} codecs to use by default
|
|
* @param {Object} the parsed media object
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'addMimeType_',
|
|
value: function addMimeType_(segmentLoader, defaultCodecs, media) {
|
|
var mimeType = 'video/mp2t';
|
|
|
|
// if the codecs were explicitly specified, pass them along to the
|
|
// source buffer
|
|
if (media.attributes && media.attributes.CODECS) {
|
|
mimeType += '; codecs="' + media.attributes.CODECS + '"';
|
|
} else {
|
|
mimeType += '; codecs="' + defaultCodecs + '"';
|
|
}
|
|
segmentLoader.mimeType(mimeType);
|
|
}
|
|
|
|
/**
|
|
* Blacklist playlists that are known to be codec or
|
|
* stream-incompatible with the SourceBuffer configuration. For
|
|
* instance, Media Source Extensions would cause the video element to
|
|
* stall waiting for video data if you switched from a variant with
|
|
* video and audio to an audio-only one.
|
|
*
|
|
* @param {Object} media a media playlist compatible with the current
|
|
* set of SourceBuffers. Variants in the current master playlist that
|
|
* do not appear to have compatible codec or stream configurations
|
|
* will be excluded from the default playlist selection algorithm
|
|
* indefinitely.
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'excludeIncompatibleVariants_',
|
|
value: function excludeIncompatibleVariants_(media) {
|
|
var master = this.masterPlaylistLoader_.master;
|
|
var codecCount = 2;
|
|
var videoCodec = null;
|
|
var audioProfile = null;
|
|
var codecs = undefined;
|
|
|
|
if (media.attributes && media.attributes.CODECS) {
|
|
codecs = parseCodecs(media.attributes.CODECS);
|
|
videoCodec = codecs.videoCodec;
|
|
audioProfile = codecs.audioProfile;
|
|
codecCount = codecs.codecCount;
|
|
}
|
|
master.playlists.forEach(function (variant) {
|
|
var variantCodecs = {
|
|
codecCount: 2,
|
|
videoCodec: null,
|
|
audioProfile: null
|
|
};
|
|
|
|
if (variant.attributes && variant.attributes.CODECS) {
|
|
variantCodecs = parseCodecs(variant.attributes.CODECS);
|
|
}
|
|
|
|
// if the streams differ in the presence or absence of audio or
|
|
// video, they are incompatible
|
|
if (variantCodecs.codecCount !== codecCount) {
|
|
variant.excludeUntil = Infinity;
|
|
}
|
|
|
|
// if h.264 is specified on the current playlist, some flavor of
|
|
// it must be specified on all compatible variants
|
|
if (variantCodecs.videoCodec !== videoCodec) {
|
|
variant.excludeUntil = Infinity;
|
|
}
|
|
// HE-AAC ("mp4a.40.5") is incompatible with all other versions of
|
|
// AAC audio in Chrome 46. Don't mix the two.
|
|
if (variantCodecs.audioProfile === '5' && audioProfile !== '5' || audioProfile === '5' && variantCodecs.audioProfile !== '5') {
|
|
variant.excludeUntil = Infinity;
|
|
}
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return MasterPlaylistController;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = MasterPlaylistController;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./hls-audio-track":6,"./playlist-loader":12,"./ranges":14,"./segment-loader":16}],12:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file playlist-loader.js
|
|
*
|
|
* A state machine that manages the loading, caching, and updating of
|
|
* M3U8 playlists.
|
|
*
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _resolveUrl = require('./resolve-url');
|
|
|
|
var _resolveUrl2 = _interopRequireDefault(_resolveUrl);
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _stream = require('./stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
var _m3u8 = require('./m3u8');
|
|
|
|
var _m3u82 = _interopRequireDefault(_m3u8);
|
|
|
|
/**
|
|
* Returns a new array of segments that is the result of merging
|
|
* properties from an older list of segments onto an updated
|
|
* list. No properties on the updated playlist will be overridden.
|
|
*
|
|
* @param {Array} original the outdated list of segments
|
|
* @param {Array} update the updated list of segments
|
|
* @param {Number=} offset the index of the first update
|
|
* segment in the original segment list. For non-live playlists,
|
|
* this should always be zero and does not need to be
|
|
* specified. For live playlists, it should be the difference
|
|
* between the media sequence numbers in the original and updated
|
|
* playlists.
|
|
* @return a list of merged segment objects
|
|
*/
|
|
var updateSegments = function updateSegments(original, update, offset) {
|
|
var result = update.slice();
|
|
var length = undefined;
|
|
var i = undefined;
|
|
|
|
offset = offset || 0;
|
|
length = Math.min(original.length, update.length + offset);
|
|
|
|
for (i = offset; i < length; i++) {
|
|
result[i - offset] = (0, _videoJs.mergeOptions)(original[i], result[i - offset]);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Returns a new master playlist that is the result of merging an
|
|
* updated media playlist into the original version. If the
|
|
* updated media playlist does not match any of the playlist
|
|
* entries in the original master playlist, null is returned.
|
|
*
|
|
* @param {Object} master a parsed master M3U8 object
|
|
* @param {Object} media a parsed media M3U8 object
|
|
* @return {Object} a new object that represents the original
|
|
* master playlist with the updated media playlist merged in, or
|
|
* null if the merge produced no change.
|
|
*/
|
|
var updateMaster = function updateMaster(master, media) {
|
|
var changed = false;
|
|
var result = (0, _videoJs.mergeOptions)(master, {});
|
|
var i = master.playlists.length;
|
|
var playlist = undefined;
|
|
var segment = undefined;
|
|
var j = undefined;
|
|
|
|
while (i--) {
|
|
playlist = result.playlists[i];
|
|
if (playlist.uri === media.uri) {
|
|
// consider the playlist unchanged if the number of segments
|
|
// are equal and the media sequence number is unchanged
|
|
if (playlist.segments && media.segments && playlist.segments.length === media.segments.length && playlist.mediaSequence === media.mediaSequence) {
|
|
continue;
|
|
}
|
|
|
|
result.playlists[i] = (0, _videoJs.mergeOptions)(playlist, media);
|
|
result.playlists[media.uri] = result.playlists[i];
|
|
|
|
// if the update could overlap existing segment information,
|
|
// merge the two lists
|
|
if (playlist.segments) {
|
|
result.playlists[i].segments = updateSegments(playlist.segments, media.segments, media.mediaSequence - playlist.mediaSequence);
|
|
}
|
|
// resolve any missing segment and key URIs
|
|
j = 0;
|
|
if (result.playlists[i].segments) {
|
|
j = result.playlists[i].segments.length;
|
|
}
|
|
while (j--) {
|
|
segment = result.playlists[i].segments[j];
|
|
if (!segment.resolvedUri) {
|
|
segment.resolvedUri = (0, _resolveUrl2['default'])(playlist.resolvedUri, segment.uri);
|
|
}
|
|
if (segment.key && !segment.key.resolvedUri) {
|
|
segment.key.resolvedUri = (0, _resolveUrl2['default'])(playlist.resolvedUri, segment.key.uri);
|
|
}
|
|
}
|
|
changed = true;
|
|
}
|
|
}
|
|
return changed ? result : null;
|
|
};
|
|
|
|
/**
|
|
* Load a playlist from a remote loacation
|
|
*
|
|
* @class PlaylistLoader
|
|
* @extends Stream
|
|
* @param {String} srcUrl the url to start with
|
|
* @param {Boolean} withCredentials the withCredentials xhr option
|
|
* @constructor
|
|
*/
|
|
var PlaylistLoader = function PlaylistLoader(srcUrl, hls, withCredentials) {
|
|
var _this = this;
|
|
|
|
/* eslint-disable consistent-this */
|
|
var loader = this;
|
|
/* eslint-enable consistent-this */
|
|
var dispose = undefined;
|
|
var mediaUpdateTimeout = undefined;
|
|
var request = undefined;
|
|
var playlistRequestError = undefined;
|
|
var haveMetadata = undefined;
|
|
|
|
PlaylistLoader.prototype.constructor.call(this);
|
|
|
|
this.hls_ = hls;
|
|
|
|
// a flag that disables "expired time"-tracking this setting has
|
|
// no effect when not playing a live stream
|
|
this.trackExpiredTime_ = false;
|
|
|
|
if (!srcUrl) {
|
|
throw new Error('A non-empty playlist URL is required');
|
|
}
|
|
|
|
playlistRequestError = function (xhr, url, startingState) {
|
|
loader.setBandwidth(request || xhr);
|
|
|
|
// any in-flight request is now finished
|
|
request = null;
|
|
|
|
if (startingState) {
|
|
loader.state = startingState;
|
|
}
|
|
|
|
loader.error = {
|
|
playlist: loader.master.playlists[url],
|
|
status: xhr.status,
|
|
message: 'HLS playlist request error at URL: ' + url,
|
|
responseText: xhr.responseText,
|
|
code: xhr.status >= 500 ? 4 : 2
|
|
};
|
|
|
|
loader.trigger('error');
|
|
};
|
|
|
|
// update the playlist loader's state in response to a new or
|
|
// updated playlist.
|
|
haveMetadata = function (xhr, url) {
|
|
var parser = undefined;
|
|
var refreshDelay = undefined;
|
|
var update = undefined;
|
|
|
|
loader.setBandwidth(request || xhr);
|
|
|
|
// any in-flight request is now finished
|
|
request = null;
|
|
|
|
loader.state = 'HAVE_METADATA';
|
|
|
|
parser = new _m3u82['default'].Parser();
|
|
parser.push(xhr.responseText);
|
|
parser.end();
|
|
parser.manifest.uri = url;
|
|
|
|
// merge this playlist into the master
|
|
update = updateMaster(loader.master, parser.manifest);
|
|
refreshDelay = (parser.manifest.targetDuration || 10) * 1000;
|
|
if (update) {
|
|
loader.master = update;
|
|
loader.updateMediaPlaylist_(parser.manifest);
|
|
} else {
|
|
// if the playlist is unchanged since the last reload,
|
|
// try again after half the target duration
|
|
refreshDelay /= 2;
|
|
}
|
|
|
|
// refresh live playlists after a target duration passes
|
|
if (!loader.media().endList) {
|
|
window.clearTimeout(mediaUpdateTimeout);
|
|
mediaUpdateTimeout = window.setTimeout(function () {
|
|
loader.trigger('mediaupdatetimeout');
|
|
}, refreshDelay);
|
|
}
|
|
|
|
loader.trigger('loadedplaylist');
|
|
};
|
|
|
|
// initialize the loader state
|
|
loader.state = 'HAVE_NOTHING';
|
|
|
|
// track the time that has expired from the live window
|
|
// this allows the seekable start range to be calculated even if
|
|
// all segments with timing information have expired
|
|
this.expired_ = 0;
|
|
|
|
// capture the prototype dispose function
|
|
dispose = this.dispose;
|
|
|
|
/**
|
|
* Abort any outstanding work and clean up.
|
|
*/
|
|
loader.dispose = function () {
|
|
loader.stopRequest();
|
|
window.clearTimeout(mediaUpdateTimeout);
|
|
dispose.call(this);
|
|
};
|
|
|
|
loader.stopRequest = function () {
|
|
if (request) {
|
|
var oldRequest = request;
|
|
|
|
request = null;
|
|
oldRequest.onreadystatechange = null;
|
|
oldRequest.abort();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* When called without any arguments, returns the currently
|
|
* active media playlist. When called with a single argument,
|
|
* triggers the playlist loader to asynchronously switch to the
|
|
* specified media playlist. Calling this method while the
|
|
* loader is in the HAVE_NOTHING causes an error to be emitted
|
|
* but otherwise has no effect.
|
|
*
|
|
* @param {Object=} playlis tthe parsed media playlist
|
|
* object to switch to
|
|
* @return {Playlist} the current loaded media
|
|
*/
|
|
loader.media = function (playlist) {
|
|
var startingState = loader.state;
|
|
var mediaChange = undefined;
|
|
|
|
// getter
|
|
if (!playlist) {
|
|
return loader.media_;
|
|
}
|
|
|
|
// setter
|
|
if (loader.state === 'HAVE_NOTHING') {
|
|
throw new Error('Cannot switch media playlist from ' + loader.state);
|
|
}
|
|
|
|
// find the playlist object if the target playlist has been
|
|
// specified by URI
|
|
if (typeof playlist === 'string') {
|
|
if (!loader.master.playlists[playlist]) {
|
|
throw new Error('Unknown playlist URI: ' + playlist);
|
|
}
|
|
playlist = loader.master.playlists[playlist];
|
|
}
|
|
|
|
mediaChange = !loader.media_ || playlist.uri !== loader.media_.uri;
|
|
|
|
// switch to fully loaded playlists immediately
|
|
if (loader.master.playlists[playlist.uri].endList) {
|
|
// abort outstanding playlist requests
|
|
if (request) {
|
|
request.onreadystatechange = null;
|
|
request.abort();
|
|
request = null;
|
|
}
|
|
loader.state = 'HAVE_METADATA';
|
|
loader.media_ = playlist;
|
|
|
|
// trigger media change if the active media has been updated
|
|
if (mediaChange) {
|
|
loader.trigger('mediachanging');
|
|
loader.trigger('mediachange');
|
|
}
|
|
return;
|
|
}
|
|
|
|
// switching to the active playlist is a no-op
|
|
if (!mediaChange) {
|
|
return;
|
|
}
|
|
|
|
loader.state = 'SWITCHING_MEDIA';
|
|
|
|
// there is already an outstanding playlist request
|
|
if (request) {
|
|
if ((0, _resolveUrl2['default'])(loader.master.uri, playlist.uri) === request.url) {
|
|
// requesting to switch to the same playlist multiple times
|
|
// has no effect after the first
|
|
return;
|
|
}
|
|
request.onreadystatechange = null;
|
|
request.abort();
|
|
request = null;
|
|
}
|
|
|
|
// request the new playlist
|
|
if (this.media_) {
|
|
this.trigger('mediachanging');
|
|
}
|
|
request = this.hls_.xhr({
|
|
uri: (0, _resolveUrl2['default'])(loader.master.uri, playlist.uri),
|
|
withCredentials: withCredentials
|
|
}, function (error, req) {
|
|
// disposed
|
|
if (!request) {
|
|
return;
|
|
}
|
|
|
|
if (error) {
|
|
return playlistRequestError(request, playlist.uri, startingState);
|
|
}
|
|
|
|
haveMetadata(req, playlist.uri);
|
|
|
|
// fire loadedmetadata the first time a media playlist is loaded
|
|
if (startingState === 'HAVE_MASTER') {
|
|
loader.trigger('loadedmetadata');
|
|
} else {
|
|
loader.trigger('mediachange');
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* set the bandwidth on an xhr to the bandwidth on the playlist
|
|
*/
|
|
loader.setBandwidth = function (xhr) {
|
|
loader.bandwidth = xhr.bandwidth;
|
|
};
|
|
|
|
// In a live playlist, don't keep track of the expired time
|
|
// until HLS tells us that "first play" has commenced
|
|
loader.on('firstplay', function () {
|
|
this.trackExpiredTime_ = true;
|
|
});
|
|
|
|
// live playlist staleness timeout
|
|
loader.on('mediaupdatetimeout', function () {
|
|
if (loader.state !== 'HAVE_METADATA') {
|
|
// only refresh the media playlist if no other activity is going on
|
|
return;
|
|
}
|
|
|
|
loader.state = 'HAVE_CURRENT_METADATA';
|
|
request = this.hls_.xhr({
|
|
uri: (0, _resolveUrl2['default'])(loader.master.uri, loader.media().uri),
|
|
withCredentials: withCredentials
|
|
}, function (error, req) {
|
|
// disposed
|
|
if (!request) {
|
|
return;
|
|
}
|
|
|
|
if (error) {
|
|
return playlistRequestError(request, loader.media().uri);
|
|
}
|
|
haveMetadata(request, loader.media().uri);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* pause loading of the playlist
|
|
*/
|
|
loader.pause = function () {
|
|
loader.stopRequest();
|
|
window.clearTimeout(mediaUpdateTimeout);
|
|
};
|
|
|
|
/**
|
|
* start loading of the playlist
|
|
*/
|
|
loader.load = function () {
|
|
if (loader.started) {
|
|
if (!loader.media().endList) {
|
|
loader.trigger('mediaupdatetimeout');
|
|
} else {
|
|
loader.trigger('loadedplaylist');
|
|
}
|
|
} else {
|
|
loader.start();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* start loading of the playlist
|
|
*/
|
|
loader.start = function () {
|
|
loader.started = true;
|
|
|
|
// request the specified URL
|
|
request = _this.hls_.xhr({
|
|
uri: srcUrl,
|
|
withCredentials: withCredentials
|
|
}, function (error, req) {
|
|
var parser = undefined;
|
|
var playlist = undefined;
|
|
var i = undefined;
|
|
|
|
// disposed
|
|
if (!request) {
|
|
return;
|
|
}
|
|
|
|
// clear the loader's request reference
|
|
request = null;
|
|
|
|
if (error) {
|
|
loader.error = {
|
|
status: req.status,
|
|
message: 'HLS playlist request error at URL: ' + srcUrl,
|
|
responseText: req.responseText,
|
|
// MEDIA_ERR_NETWORK
|
|
code: 2
|
|
};
|
|
return loader.trigger('error');
|
|
}
|
|
|
|
parser = new _m3u82['default'].Parser();
|
|
parser.push(req.responseText);
|
|
parser.end();
|
|
|
|
loader.state = 'HAVE_MASTER';
|
|
|
|
parser.manifest.uri = srcUrl;
|
|
|
|
// loaded a master playlist
|
|
if (parser.manifest.playlists) {
|
|
loader.master = parser.manifest;
|
|
|
|
// setup by-URI lookups and resolve media playlist URIs
|
|
i = loader.master.playlists.length;
|
|
while (i--) {
|
|
playlist = loader.master.playlists[i];
|
|
loader.master.playlists[playlist.uri] = playlist;
|
|
playlist.resolvedUri = (0, _resolveUrl2['default'])(loader.master.uri, playlist.uri);
|
|
}
|
|
|
|
// resolve any media group URIs
|
|
for (var groupKey in loader.master.mediaGroups.AUDIO) {
|
|
for (var labelKey in loader.master.mediaGroups.AUDIO[groupKey]) {
|
|
var alternateAudio = loader.master.mediaGroups.AUDIO[groupKey][labelKey];
|
|
if (alternateAudio.uri) {
|
|
alternateAudio.resolvedUri = (0, _resolveUrl2['default'])(loader.master.uri, alternateAudio.uri);
|
|
}
|
|
}
|
|
}
|
|
|
|
loader.trigger('loadedplaylist');
|
|
if (!request) {
|
|
// no media playlist was specifically selected so start
|
|
// from the first listed one
|
|
loader.media(parser.manifest.playlists[0]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// loaded a media playlist
|
|
// infer a master playlist if none was previously requested
|
|
loader.master = {
|
|
uri: window.location.href,
|
|
playlists: [{
|
|
uri: srcUrl
|
|
}]
|
|
};
|
|
loader.master.playlists[srcUrl] = loader.master.playlists[0];
|
|
loader.master.playlists[0].resolvedUri = srcUrl;
|
|
haveMetadata(req, srcUrl);
|
|
return loader.trigger('loadedmetadata');
|
|
});
|
|
};
|
|
};
|
|
|
|
PlaylistLoader.prototype = new _stream2['default']();
|
|
|
|
/**
|
|
* Update the PlaylistLoader state to reflect the changes in an
|
|
* update to the current media playlist.
|
|
*
|
|
* @param {Object} update the updated media playlist object
|
|
*/
|
|
PlaylistLoader.prototype.updateMediaPlaylist_ = function (update) {
|
|
var outdated = undefined;
|
|
var i = undefined;
|
|
var segment = undefined;
|
|
|
|
outdated = this.media_;
|
|
this.media_ = this.master.playlists[update.uri];
|
|
|
|
if (!outdated) {
|
|
return;
|
|
}
|
|
|
|
// don't track expired time until this flag is truthy
|
|
if (!this.trackExpiredTime_) {
|
|
return;
|
|
}
|
|
|
|
// if the update was the result of a rendition switch do not
|
|
// attempt to calculate expired_ since media-sequences need not
|
|
// correlate between renditions/variants
|
|
if (update.uri !== outdated.uri) {
|
|
return;
|
|
}
|
|
|
|
// try using precise timing from first segment of the updated
|
|
// playlist
|
|
if (update.segments.length) {
|
|
if (typeof update.segments[0].start !== 'undefined') {
|
|
this.expired_ = update.segments[0].start;
|
|
return;
|
|
} else if (typeof update.segments[0].end !== 'undefined') {
|
|
this.expired_ = update.segments[0].end - update.segments[0].duration;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// calculate expired by walking the outdated playlist
|
|
i = update.mediaSequence - outdated.mediaSequence - 1;
|
|
|
|
for (; i >= 0; i--) {
|
|
segment = outdated.segments[i];
|
|
|
|
if (!segment) {
|
|
// we missed information on this segment completely between
|
|
// playlist updates so we'll have to take an educated guess
|
|
// once we begin buffering again, any error we introduce can
|
|
// be corrected
|
|
this.expired_ += outdated.targetDuration || 10;
|
|
continue;
|
|
}
|
|
|
|
if (typeof segment.end !== 'undefined') {
|
|
this.expired_ = segment.end;
|
|
return;
|
|
}
|
|
if (typeof segment.start !== 'undefined') {
|
|
this.expired_ = segment.start + segment.duration;
|
|
return;
|
|
}
|
|
this.expired_ += segment.duration;
|
|
}
|
|
};
|
|
|
|
exports['default'] = PlaylistLoader;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./m3u8":7,"./resolve-url":15,"./stream":18}],13:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file playlist.js
|
|
*
|
|
* Playlist related utilities.
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var Playlist = {
|
|
/**
|
|
* The number of segments that are unsafe to start playback at in
|
|
* a live stream. Changing this value can cause playback stalls.
|
|
* See HTTP Live Streaming, "Playing the Media Playlist File"
|
|
* https://tools.ietf.org/html/draft-pantos-http-live-streaming-18#section-6.3.3
|
|
*/
|
|
UNSAFE_LIVE_SEGMENTS: 3
|
|
};
|
|
|
|
/**
|
|
* walk backward until we find a duration we can use
|
|
* or return a failure
|
|
*
|
|
* @param {Playlist} playlist the playlist to walk through
|
|
* @param {Number} endSequence the mediaSequence to stop walking on
|
|
*/
|
|
|
|
var backwardDuration = function backwardDuration(playlist, endSequence) {
|
|
var result = 0;
|
|
var i = endSequence - playlist.mediaSequence;
|
|
// if a start time is available for segment immediately following
|
|
// the interval, use it
|
|
var segment = playlist.segments[i];
|
|
|
|
// Walk backward until we find the latest segment with timeline
|
|
// information that is earlier than endSequence
|
|
if (segment) {
|
|
if (typeof segment.start !== 'undefined') {
|
|
return { result: segment.start, precise: true };
|
|
}
|
|
if (typeof segment.end !== 'undefined') {
|
|
return {
|
|
result: segment.end - segment.duration,
|
|
precise: true
|
|
};
|
|
}
|
|
}
|
|
while (i--) {
|
|
segment = playlist.segments[i];
|
|
if (typeof segment.end !== 'undefined') {
|
|
return { result: result + segment.end, precise: true };
|
|
}
|
|
|
|
result += segment.duration;
|
|
|
|
if (typeof segment.start !== 'undefined') {
|
|
return { result: result + segment.start, precise: true };
|
|
}
|
|
}
|
|
return { result: result, precise: false };
|
|
};
|
|
|
|
/**
|
|
* walk forward until we find a duration we can use
|
|
* or return a failure
|
|
*
|
|
* @param {Playlist} playlist the playlist to walk through
|
|
* @param {Number} endSequence the mediaSequence to stop walking on
|
|
*/
|
|
var forwardDuration = function forwardDuration(playlist, endSequence) {
|
|
var result = 0;
|
|
var segment = undefined;
|
|
var i = endSequence - playlist.mediaSequence;
|
|
// Walk forward until we find the earliest segment with timeline
|
|
// information
|
|
|
|
for (; i < playlist.segments.length; i++) {
|
|
segment = playlist.segments[i];
|
|
if (typeof segment.start !== 'undefined') {
|
|
return {
|
|
result: segment.start - result,
|
|
precise: true
|
|
};
|
|
}
|
|
|
|
result += segment.duration;
|
|
|
|
if (typeof segment.end !== 'undefined') {
|
|
return {
|
|
result: segment.end - result,
|
|
precise: true
|
|
};
|
|
}
|
|
}
|
|
// indicate we didn't find a useful duration estimate
|
|
return { result: -1, precise: false };
|
|
};
|
|
|
|
/**
|
|
* Calculate the media duration from the segments associated with a
|
|
* playlist. The duration of a subinterval of the available segments
|
|
* may be calculated by specifying an end index.
|
|
*
|
|
* @param {Object} playlist a media playlist object
|
|
* @param {Number=} endSequence an exclusive upper boundary
|
|
* for the playlist. Defaults to playlist length.
|
|
* @param {Number} expired the amount of time that has dropped
|
|
* off the front of the playlist in a live scenario
|
|
* @return {Number} the duration between the first available segment
|
|
* and end index.
|
|
*/
|
|
var intervalDuration = function intervalDuration(playlist, endSequence, expired) {
|
|
var backward = undefined;
|
|
var forward = undefined;
|
|
|
|
if (typeof endSequence === 'undefined') {
|
|
endSequence = playlist.mediaSequence + playlist.segments.length;
|
|
}
|
|
|
|
if (endSequence < playlist.mediaSequence) {
|
|
return 0;
|
|
}
|
|
|
|
// do a backward walk to estimate the duration
|
|
backward = backwardDuration(playlist, endSequence);
|
|
if (backward.precise) {
|
|
// if we were able to base our duration estimate on timing
|
|
// information provided directly from the Media Source, return
|
|
// it
|
|
return backward.result;
|
|
}
|
|
|
|
// walk forward to see if a precise duration estimate can be made
|
|
// that way
|
|
forward = forwardDuration(playlist, endSequence);
|
|
if (forward.precise) {
|
|
// we found a segment that has been buffered and so it's
|
|
// position is known precisely
|
|
return forward.result;
|
|
}
|
|
|
|
// return the less-precise, playlist-based duration estimate
|
|
return backward.result + expired;
|
|
};
|
|
|
|
/**
|
|
* Calculates the duration of a playlist. If a start and end index
|
|
* are specified, the duration will be for the subset of the media
|
|
* timeline between those two indices. The total duration for live
|
|
* playlists is always Infinity.
|
|
*
|
|
* @param {Object} playlist a media playlist object
|
|
* @param {Number=} endSequence an exclusive upper
|
|
* boundary for the playlist. Defaults to the playlist media
|
|
* sequence number plus its length.
|
|
* @param {Number=} expired the amount of time that has
|
|
* dropped off the front of the playlist in a live scenario
|
|
* @return {Number} the duration between the start index and end
|
|
* index.
|
|
*/
|
|
var duration = function duration(playlist, endSequence, expired) {
|
|
if (!playlist) {
|
|
return 0;
|
|
}
|
|
|
|
if (typeof expired !== 'number') {
|
|
expired = 0;
|
|
}
|
|
|
|
// if a slice of the total duration is not requested, use
|
|
// playlist-level duration indicators when they're present
|
|
if (typeof endSequence === 'undefined') {
|
|
// if present, use the duration specified in the playlist
|
|
if (playlist.totalDuration) {
|
|
return playlist.totalDuration;
|
|
}
|
|
|
|
// duration should be Infinity for live playlists
|
|
if (!playlist.endList) {
|
|
return window.Infinity;
|
|
}
|
|
}
|
|
|
|
// calculate the total duration based on the segment durations
|
|
return intervalDuration(playlist, endSequence, expired);
|
|
};
|
|
|
|
exports.duration = duration;
|
|
/**
|
|
* Calculates the interval of time that is currently seekable in a
|
|
* playlist. The returned time ranges are relative to the earliest
|
|
* moment in the specified playlist that is still available. A full
|
|
* seekable implementation for live streams would need to offset
|
|
* these values by the duration of content that has expired from the
|
|
* stream.
|
|
*
|
|
* @param {Object} playlist a media playlist object
|
|
* @param {Number=} expired the amount of time that has
|
|
* dropped off the front of the playlist in a live scenario
|
|
* @return {TimeRanges} the periods of time that are valid targets
|
|
* for seeking
|
|
*/
|
|
var seekable = function seekable(playlist, expired) {
|
|
var start = undefined;
|
|
var end = undefined;
|
|
var endSequence = undefined;
|
|
|
|
if (typeof expired !== 'number') {
|
|
expired = 0;
|
|
}
|
|
|
|
// without segments, there are no seekable ranges
|
|
if (!playlist || !playlist.segments) {
|
|
return (0, _videoJs.createTimeRange)();
|
|
}
|
|
// when the playlist is complete, the entire duration is seekable
|
|
if (playlist.endList) {
|
|
return (0, _videoJs.createTimeRange)(0, duration(playlist));
|
|
}
|
|
|
|
// live playlists should not expose three segment durations worth
|
|
// of content from the end of the playlist
|
|
// https://tools.ietf.org/html/draft-pantos-http-live-streaming-16#section-6.3.3
|
|
start = intervalDuration(playlist, playlist.mediaSequence, expired);
|
|
endSequence = Math.max(0, playlist.segments.length - Playlist.UNSAFE_LIVE_SEGMENTS);
|
|
end = intervalDuration(playlist, playlist.mediaSequence + endSequence, expired);
|
|
return (0, _videoJs.createTimeRange)(start, end);
|
|
};
|
|
|
|
exports.seekable = seekable;
|
|
/**
|
|
* Determine the index of the segment that contains a specified
|
|
* playback position in a media playlist.
|
|
*
|
|
* @param {Object} playlist the media playlist to query
|
|
* @param {Number} time The number of seconds since the earliest
|
|
* possible position to determine the containing segment for
|
|
* @param {Number=} expired the duration of content, in
|
|
* seconds, that has been removed from this playlist because it
|
|
* expired
|
|
* @return {Number} The number of the media segment that contains
|
|
* that time position.
|
|
*/
|
|
var getMediaIndexForTime_ = function getMediaIndexForTime_(playlist, time, expired) {
|
|
var i = undefined;
|
|
var segment = undefined;
|
|
var originalTime = time;
|
|
var numSegments = playlist.segments.length;
|
|
var lastSegment = numSegments - 1;
|
|
var startIndex = undefined;
|
|
var endIndex = undefined;
|
|
var knownStart = undefined;
|
|
var knownEnd = undefined;
|
|
|
|
if (!playlist) {
|
|
return 0;
|
|
}
|
|
|
|
// when the requested position is earlier than the current set of
|
|
// segments, return the earliest segment index
|
|
if (time < 0) {
|
|
return 0;
|
|
}
|
|
|
|
expired = expired || 0;
|
|
|
|
// find segments with known timing information that bound the
|
|
// target time
|
|
for (i = 0; i < numSegments; i++) {
|
|
segment = playlist.segments[i];
|
|
if (segment.end) {
|
|
if (segment.end > time) {
|
|
knownEnd = segment.end;
|
|
endIndex = i;
|
|
break;
|
|
} else {
|
|
knownStart = segment.end;
|
|
startIndex = i + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// time was equal to or past the end of the last segment in the playlist
|
|
if (startIndex === numSegments) {
|
|
return numSegments;
|
|
}
|
|
|
|
// use the bounds we just found and playlist information to
|
|
// estimate the segment that contains the time we are looking for
|
|
if (typeof startIndex !== 'undefined') {
|
|
// We have a known-start point that is before our desired time so
|
|
// walk from that point forwards
|
|
time = time - knownStart;
|
|
for (i = startIndex; i < (endIndex || numSegments); i++) {
|
|
segment = playlist.segments[i];
|
|
time -= segment.duration;
|
|
|
|
if (time < 0) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
if (i >= endIndex) {
|
|
// We haven't found a segment but we did hit a known end point
|
|
// so fallback to interpolating between the segment index
|
|
// based on the known span of the timeline we are dealing with
|
|
// and the number of segments inside that span
|
|
return startIndex + Math.floor((originalTime - knownStart) / (knownEnd - knownStart) * (endIndex - startIndex));
|
|
}
|
|
|
|
// We _still_ haven't found a segment so load the last one
|
|
return lastSegment;
|
|
} else if (typeof endIndex !== 'undefined') {
|
|
// We _only_ have a known-end point that is after our desired time so
|
|
// walk from that point backwards
|
|
time = knownEnd - time;
|
|
for (i = endIndex; i >= 0; i--) {
|
|
segment = playlist.segments[i];
|
|
time -= segment.duration;
|
|
|
|
if (time < 0) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
// We haven't found a segment so load the first one if time is zero
|
|
if (time === 0) {
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
// We known nothing so walk from the front of the playlist,
|
|
// subtracting durations until we find a segment that contains
|
|
// time and return it
|
|
time = time - expired;
|
|
|
|
if (time < 0) {
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < numSegments; i++) {
|
|
segment = playlist.segments[i];
|
|
time -= segment.duration;
|
|
if (time < 0) {
|
|
return i;
|
|
}
|
|
}
|
|
// We are out of possible candidates so load the last one...
|
|
// The last one is the least likely to overlap a buffer and therefore
|
|
// the one most likely to tell us something about the timeline
|
|
return lastSegment;
|
|
};
|
|
|
|
exports.getMediaIndexForTime_ = getMediaIndexForTime_;
|
|
Playlist.duration = duration;
|
|
Playlist.seekable = seekable;
|
|
Playlist.getMediaIndexForTime_ = getMediaIndexForTime_;
|
|
|
|
// exports
|
|
exports['default'] = Playlist;
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],14:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* ranges
|
|
*
|
|
* Utilities for working with TimeRanges.
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
// Fudge factor to account for TimeRanges rounding
|
|
var TIME_FUDGE_FACTOR = 1 / 30;
|
|
|
|
var filterRanges = function filterRanges(timeRanges, predicate) {
|
|
var results = [];
|
|
var i = undefined;
|
|
|
|
if (timeRanges && timeRanges.length) {
|
|
// Search for ranges that match the predicate
|
|
for (i = 0; i < timeRanges.length; i++) {
|
|
if (predicate(timeRanges.start(i), timeRanges.end(i))) {
|
|
results.push([timeRanges.start(i), timeRanges.end(i)]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _videoJs2['default'].createTimeRanges(results);
|
|
};
|
|
|
|
/**
|
|
* Attempts to find the buffered TimeRange that contains the specified
|
|
* time.
|
|
* @param {TimeRanges} buffered - the TimeRanges object to query
|
|
* @param {number} time - the time to filter on.
|
|
* @returns {TimeRanges} a new TimeRanges object
|
|
*/
|
|
var findRange = function findRange(buffered, time) {
|
|
return filterRanges(buffered, function (start, end) {
|
|
return start - TIME_FUDGE_FACTOR <= time && end + TIME_FUDGE_FACTOR >= time;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Returns the TimeRanges that begin at or later than the specified
|
|
* time.
|
|
* @param {TimeRanges} timeRanges - the TimeRanges object to query
|
|
* @param {number} time - the time to filter on.
|
|
* @returns {TimeRanges} a new TimeRanges object.
|
|
*/
|
|
var findNextRange = function findNextRange(timeRanges, time) {
|
|
return filterRanges(timeRanges, function (start) {
|
|
return start - TIME_FUDGE_FACTOR >= time;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Search for a likely end time for the segment that was just appened
|
|
* based on the state of the `buffered` property before and after the
|
|
* append. If we fin only one such uncommon end-point return it.
|
|
* @param {TimeRanges} original - the buffered time ranges before the update
|
|
* @param {TimeRanges} update - the buffered time ranges after the update
|
|
* @returns {Number|null} the end time added between `original` and `update`,
|
|
* or null if one cannot be unambiguously determined.
|
|
*/
|
|
var findSoleUncommonTimeRangesEnd = function findSoleUncommonTimeRangesEnd(original, update) {
|
|
var i = undefined;
|
|
var start = undefined;
|
|
var end = undefined;
|
|
var result = [];
|
|
var edges = [];
|
|
|
|
// In order to qualify as a possible candidate, the end point must:
|
|
// 1) Not have already existed in the `original` ranges
|
|
// 2) Not result from the shrinking of a range that already existed
|
|
// in the `original` ranges
|
|
// 3) Not be contained inside of a range that existed in `original`
|
|
var overlapsCurrentEnd = function overlapsCurrentEnd(span) {
|
|
return span[0] <= end && span[1] >= end;
|
|
};
|
|
|
|
if (original) {
|
|
// Save all the edges in the `original` TimeRanges object
|
|
for (i = 0; i < original.length; i++) {
|
|
start = original.start(i);
|
|
end = original.end(i);
|
|
|
|
edges.push([start, end]);
|
|
}
|
|
}
|
|
|
|
if (update) {
|
|
// Save any end-points in `update` that are not in the `original`
|
|
// TimeRanges object
|
|
for (i = 0; i < update.length; i++) {
|
|
start = update.start(i);
|
|
end = update.end(i);
|
|
|
|
if (edges.some(overlapsCurrentEnd)) {
|
|
continue;
|
|
}
|
|
|
|
// at this point it must be a unique non-shrinking end edge
|
|
result.push(end);
|
|
}
|
|
}
|
|
|
|
// we err on the side of caution and return null if didn't find
|
|
// exactly *one* differing end edge in the search above
|
|
if (result.length !== 1) {
|
|
return null;
|
|
}
|
|
|
|
return result[0];
|
|
};
|
|
|
|
/**
|
|
* Calculate the intersection of two TimeRanges
|
|
* @param {TimeRanges} bufferA
|
|
* @param {TimeRanges} bufferB
|
|
* @returns {TimeRanges} The interesection of `bufferA` with `bufferB`
|
|
*/
|
|
var bufferIntersection = function bufferIntersection(bufferA, bufferB) {
|
|
var start = null;
|
|
var end = null;
|
|
var arity = 0;
|
|
var extents = [];
|
|
var ranges = [];
|
|
|
|
if (!bufferA || !bufferA.length || !bufferB || !bufferB.length) {
|
|
return _videoJs2['default'].createTimeRange();
|
|
}
|
|
|
|
// Handle the case where we have both buffers and create an
|
|
// intersection of the two
|
|
var count = bufferA.length;
|
|
|
|
// A) Gather up all start and end times
|
|
while (count--) {
|
|
extents.push({ time: bufferA.start(count), type: 'start' });
|
|
extents.push({ time: bufferA.end(count), type: 'end' });
|
|
}
|
|
count = bufferB.length;
|
|
while (count--) {
|
|
extents.push({ time: bufferB.start(count), type: 'start' });
|
|
extents.push({ time: bufferB.end(count), type: 'end' });
|
|
}
|
|
// B) Sort them by time
|
|
extents.sort(function (a, b) {
|
|
return a.time - b.time;
|
|
});
|
|
|
|
// C) Go along one by one incrementing arity for start and decrementing
|
|
// arity for ends
|
|
for (count = 0; count < extents.length; count++) {
|
|
if (extents[count].type === 'start') {
|
|
arity++;
|
|
|
|
// D) If arity is ever incremented to 2 we are entering an
|
|
// overlapping range
|
|
if (arity === 2) {
|
|
start = extents[count].time;
|
|
}
|
|
} else if (extents[count].type === 'end') {
|
|
arity--;
|
|
|
|
// E) If arity is ever decremented to 1 we leaving an
|
|
// overlapping range
|
|
if (arity === 1) {
|
|
end = extents[count].time;
|
|
}
|
|
}
|
|
|
|
// F) Record overlapping ranges
|
|
if (start !== null && end !== null) {
|
|
ranges.push([start, end]);
|
|
start = null;
|
|
end = null;
|
|
}
|
|
}
|
|
|
|
return _videoJs2['default'].createTimeRanges(ranges);
|
|
};
|
|
|
|
/**
|
|
* Calculates the percentage of `segmentRange` that overlaps the
|
|
* `buffered` time ranges.
|
|
* @param {TimeRanges} segmentRange - the time range that the segment covers
|
|
* @param {TimeRanges} buffered - the currently buffered time ranges
|
|
* @returns {Number} percent of the segment currently buffered
|
|
*/
|
|
var calculateBufferedPercent = function calculateBufferedPercent(segmentRange, buffered) {
|
|
var segmentDuration = segmentRange.end(0) - segmentRange.start(0);
|
|
var intersection = bufferIntersection(segmentRange, buffered);
|
|
var overlapDuration = 0;
|
|
var count = intersection.length;
|
|
|
|
while (count--) {
|
|
overlapDuration += intersection.end(count) - intersection.start(count);
|
|
}
|
|
|
|
return overlapDuration / segmentDuration * 100;
|
|
};
|
|
|
|
exports['default'] = {
|
|
findRange: findRange,
|
|
findNextRange: findNextRange,
|
|
findSoleUncommonTimeRangesEnd: findSoleUncommonTimeRangesEnd,
|
|
calculateBufferedPercent: calculateBufferedPercent,
|
|
TIME_FUDGE_FACTOR: TIME_FUDGE_FACTOR
|
|
};
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],15:[function(require,module,exports){
|
|
/**
|
|
* @file resolve-url.js
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _globalDocument = require('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
/**
|
|
* Constructs a new URI by interpreting a path relative to another
|
|
* URI.
|
|
*
|
|
* @see http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
|
|
* @param {String} basePath a relative or absolute URI
|
|
* @param {String} path a path part to combine with the base
|
|
* @return {String} a URI that is equivalent to composing `base`
|
|
* with `path`
|
|
*/
|
|
var resolveUrl = function resolveUrl(basePath, path) {
|
|
// use the base element to get the browser to handle URI resolution
|
|
var oldBase = _globalDocument2['default'].querySelector('base');
|
|
var docHead = _globalDocument2['default'].querySelector('head');
|
|
var a = _globalDocument2['default'].createElement('a');
|
|
var base = oldBase;
|
|
var oldHref = undefined;
|
|
var result = undefined;
|
|
|
|
// prep the document
|
|
if (oldBase) {
|
|
oldHref = oldBase.href;
|
|
} else {
|
|
base = docHead.appendChild(_globalDocument2['default'].createElement('base'));
|
|
}
|
|
|
|
base.href = basePath;
|
|
a.href = path;
|
|
result = a.href;
|
|
|
|
// clean up
|
|
if (oldBase) {
|
|
oldBase.href = oldHref;
|
|
} else {
|
|
docHead.removeChild(base);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
exports['default'] = resolveUrl;
|
|
module.exports = exports['default'];
|
|
},{"global/document":21}],16:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file segment-loader.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _ranges = require('./ranges');
|
|
|
|
var _ranges2 = _interopRequireDefault(_ranges);
|
|
|
|
var _playlist = require('./playlist');
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _sourceUpdater = require('./source-updater');
|
|
|
|
var _sourceUpdater2 = _interopRequireDefault(_sourceUpdater);
|
|
|
|
var _decrypter = require('./decrypter');
|
|
|
|
// in ms
|
|
var CHECK_BUFFER_DELAY = 500;
|
|
|
|
// the desired length of video to maintain in the buffer, in seconds
|
|
var GOAL_BUFFER_LENGTH = 30;
|
|
|
|
exports.GOAL_BUFFER_LENGTH = GOAL_BUFFER_LENGTH;
|
|
/**
|
|
* Updates segment with information about its end-point in time and, optionally,
|
|
* the segment duration if we have enough information to determine a segment duration
|
|
* accurately.
|
|
*
|
|
* @param {Object} playlist a media playlist object
|
|
* @param {Number} segmentIndex the index of segment we last appended
|
|
* @param {Number} segmentEnd the known of the segment referenced by segmentIndex
|
|
*/
|
|
var updateSegmentMetadata = function updateSegmentMetadata(playlist, segmentIndex, segmentEnd) {
|
|
if (!playlist) {
|
|
return false;
|
|
}
|
|
|
|
var segment = playlist.segments[segmentIndex];
|
|
var previousSegment = playlist.segments[segmentIndex - 1];
|
|
|
|
if (segmentEnd && segment) {
|
|
segment.end = segmentEnd;
|
|
|
|
// fix up segment durations based on segment end data
|
|
if (!previousSegment) {
|
|
// first segment is always has a start time of 0 making its duration
|
|
// equal to the segment end
|
|
segment.duration = segment.end;
|
|
} else if (previousSegment.end) {
|
|
segment.duration = segment.end - previousSegment.end;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Determines if we should call endOfStream on the media source based
|
|
* on the state of the buffer or if appened segment was the final
|
|
* segment in the playlist.
|
|
*
|
|
* @param {Object} playlist a media playlist object
|
|
* @param {Object} mediaSource the MediaSource object
|
|
* @param {Number} segmentIndex the index of segment we last appended
|
|
* @param {Object} currentBuffered buffered region that currentTime resides in
|
|
* @returns {Boolean} do we need to call endOfStream on the MediaSource
|
|
*/
|
|
var detectEndOfStream = function detectEndOfStream(playlist, mediaSource, segmentIndex, currentBuffered) {
|
|
if (!playlist) {
|
|
return false;
|
|
}
|
|
|
|
var segments = playlist.segments;
|
|
|
|
// determine a few boolean values to help make the branch below easier
|
|
// to read
|
|
var appendedLastSegment = segmentIndex === segments.length - 1;
|
|
var bufferedToEnd = currentBuffered.length && segments[segments.length - 1].end <= currentBuffered.end(0);
|
|
|
|
// if we've buffered to the end of the video, we need to call endOfStream
|
|
// so that MediaSources can trigger the `ended` event when it runs out of
|
|
// buffered data instead of waiting for me
|
|
return playlist.endList && mediaSource.readyState === 'open' && (appendedLastSegment || bufferedToEnd);
|
|
};
|
|
|
|
/* Turns segment byterange into a string suitable for use in
|
|
* HTTP Range requests
|
|
*/
|
|
var byterangeStr = function byterangeStr(byterange) {
|
|
var byterangeStart = undefined;
|
|
var byterangeEnd = undefined;
|
|
|
|
// `byterangeEnd` is one less than `offset + length` because the HTTP range
|
|
// header uses inclusive ranges
|
|
byterangeEnd = byterange.offset + byterange.length - 1;
|
|
byterangeStart = byterange.offset;
|
|
return 'bytes=' + byterangeStart + '-' + byterangeEnd;
|
|
};
|
|
|
|
/* Defines headers for use in the xhr request for a particular segment.
|
|
*/
|
|
var segmentXhrHeaders = function segmentXhrHeaders(segment) {
|
|
var headers = {};
|
|
|
|
if ('byterange' in segment) {
|
|
headers.Range = byterangeStr(segment.byterange);
|
|
}
|
|
return headers;
|
|
};
|
|
|
|
/**
|
|
* An object that manages segment loading and appending.
|
|
*
|
|
* @class SegmentLoader
|
|
* @param {Object} options required and optional options
|
|
* @extends videojs.EventTarget
|
|
*/
|
|
|
|
var SegmentLoader = (function (_videojs$EventTarget) {
|
|
_inherits(SegmentLoader, _videojs$EventTarget);
|
|
|
|
function SegmentLoader(options) {
|
|
_classCallCheck(this, SegmentLoader);
|
|
|
|
_get(Object.getPrototypeOf(SegmentLoader.prototype), 'constructor', this).call(this);
|
|
var settings = undefined;
|
|
|
|
// check pre-conditions
|
|
if (!options) {
|
|
throw new TypeError('Initialization options are required');
|
|
}
|
|
if (typeof options.currentTime !== 'function') {
|
|
throw new TypeError('No currentTime getter specified');
|
|
}
|
|
if (!options.mediaSource) {
|
|
throw new TypeError('No MediaSource specified');
|
|
}
|
|
settings = _videoJs2['default'].mergeOptions(_videoJs2['default'].options.hls, options);
|
|
|
|
// public properties
|
|
this.state = 'INIT';
|
|
this.bandwidth = settings.bandwidth;
|
|
this.roundTrip = NaN;
|
|
this.bytesReceived = 0;
|
|
|
|
// private properties
|
|
this.hasPlayed_ = settings.hasPlayed;
|
|
this.currentTime_ = settings.currentTime;
|
|
this.seekable_ = settings.seekable;
|
|
this.seeking_ = settings.seeking;
|
|
this.setCurrentTime_ = settings.setCurrentTime;
|
|
this.mediaSource_ = settings.mediaSource;
|
|
this.withCredentials_ = settings.withCredentials;
|
|
this.checkBufferTimeout_ = null;
|
|
this.error_ = void 0;
|
|
this.expired_ = 0;
|
|
this.timeCorrection_ = 0;
|
|
this.currentTimeline_ = -1;
|
|
this.xhr_ = null;
|
|
this.pendingSegment_ = null;
|
|
this.sourceUpdater_ = null;
|
|
this.hls_ = settings.hls;
|
|
}
|
|
|
|
/**
|
|
* dispose of the SegmentLoader and reset to the default state
|
|
*/
|
|
|
|
_createClass(SegmentLoader, [{
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
this.state = 'DISPOSED';
|
|
this.abort_();
|
|
if (this.sourceUpdater_) {
|
|
this.sourceUpdater_.dispose();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* abort anything that is currently doing on with the SegmentLoader
|
|
* and reset to a default state
|
|
*/
|
|
}, {
|
|
key: 'abort',
|
|
value: function abort() {
|
|
if (this.state !== 'WAITING') {
|
|
return;
|
|
}
|
|
|
|
this.abort_();
|
|
|
|
// don't wait for buffer check timeouts to begin fetching the
|
|
// next segment
|
|
if (!this.paused()) {
|
|
this.state = 'READY';
|
|
this.fillBuffer_();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set an error on the segment loader and null out any pending segements
|
|
*
|
|
* @param {Error} error the error to set on the SegmentLoader
|
|
* @return {Error} the error that was set or that is currently set
|
|
*/
|
|
}, {
|
|
key: 'error',
|
|
value: function error(_error) {
|
|
if (typeof _error !== 'undefined') {
|
|
this.error_ = _error;
|
|
}
|
|
|
|
this.pendingSegment_ = null;
|
|
return this.error_;
|
|
}
|
|
|
|
/**
|
|
* load a playlist and start to fill the buffer
|
|
*/
|
|
}, {
|
|
key: 'load',
|
|
value: function load() {
|
|
this.monitorBuffer_();
|
|
|
|
// if we don't have a playlist yet, keep waiting for one to be
|
|
// specified
|
|
if (!this.playlist_) {
|
|
return;
|
|
}
|
|
|
|
// if we're in the middle of processing a segment already, don't
|
|
// kick off an additional segment request
|
|
if (!this.sourceUpdater_ || this.state !== 'READY' && this.state !== 'INIT') {
|
|
return;
|
|
}
|
|
|
|
this.state = 'READY';
|
|
this.fillBuffer_();
|
|
}
|
|
|
|
/**
|
|
* set a playlist on the segment loader
|
|
*
|
|
* @param {PlaylistLoader} media the playlist to set on the segment loader
|
|
*/
|
|
}, {
|
|
key: 'playlist',
|
|
value: function playlist(media) {
|
|
this.playlist_ = media;
|
|
// if we were unpaused but waiting for a playlist, start
|
|
// buffering now
|
|
if (this.sourceUpdater_ && media && this.state === 'INIT' && !this.paused()) {
|
|
this.state = 'READY';
|
|
return this.fillBuffer_();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prevent the loader from fetching additional segments. If there
|
|
* is a segment request outstanding, it will finish processing
|
|
* before the loader halts. A segment loader can be unpaused by
|
|
* calling load().
|
|
*/
|
|
}, {
|
|
key: 'pause',
|
|
value: function pause() {
|
|
if (this.checkBufferTimeout_) {
|
|
window.clearTimeout(this.checkBufferTimeout_);
|
|
|
|
this.checkBufferTimeout_ = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns whether the segment loader is fetching additional
|
|
* segments when given the opportunity. This property can be
|
|
* modified through calls to pause() and load().
|
|
*/
|
|
}, {
|
|
key: 'paused',
|
|
value: function paused() {
|
|
return this.checkBufferTimeout_ === null;
|
|
}
|
|
|
|
/**
|
|
* setter for expired time on the SegmentLoader
|
|
*
|
|
* @param {Number} expired the exired time to set
|
|
*/
|
|
}, {
|
|
key: 'expired',
|
|
value: function expired(_expired) {
|
|
this.expired_ = _expired;
|
|
}
|
|
|
|
/**
|
|
* create/set the following mimetype on the SourceBuffer through a
|
|
* SourceUpdater
|
|
*
|
|
* @param {String} mimeType the mime type string to use
|
|
*/
|
|
}, {
|
|
key: 'mimeType',
|
|
value: function mimeType(_mimeType) {
|
|
// TODO Allow source buffers to be re-created with different mime-types
|
|
if (!this.sourceUpdater_) {
|
|
this.sourceUpdater_ = new _sourceUpdater2['default'](this.mediaSource_, _mimeType);
|
|
this.clearBuffer();
|
|
|
|
// if we were unpaused but waiting for a sourceUpdater, start
|
|
// buffering now
|
|
if (this.playlist_ && this.state === 'INIT' && !this.paused()) {
|
|
this.state = 'READY';
|
|
return this.fillBuffer_();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* asynchronously/recursively monitor the buffer
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'monitorBuffer_',
|
|
value: function monitorBuffer_() {
|
|
if (this.state === 'READY') {
|
|
this.fillBuffer_();
|
|
}
|
|
|
|
if (this.checkBufferTimeout_) {
|
|
window.clearTimeout(this.checkBufferTimeout_);
|
|
}
|
|
|
|
this.checkBufferTimeout_ = window.setTimeout(this.monitorBuffer_.bind(this), CHECK_BUFFER_DELAY);
|
|
}
|
|
|
|
/**
|
|
* Return the amount of a segment specified by the mediaIndex overlaps
|
|
* the current buffered content.
|
|
*
|
|
* @param {Object} playlist the playlist object to fetch segments from
|
|
* @param {Number} mediaIndex the index of the segment in the playlist
|
|
* @param {TimeRanges} buffered the state of the buffer
|
|
* @returns {Number} percentage of the segment's time range that is
|
|
* already in `buffered`
|
|
*/
|
|
}, {
|
|
key: 'getSegmentBufferedPercent_',
|
|
value: function getSegmentBufferedPercent_(playlist, mediaIndex, currentTime, buffered) {
|
|
var segment = playlist.segments[mediaIndex];
|
|
var startOfSegment = (0, _playlist.duration)(playlist, playlist.mediaSequence + mediaIndex, this.expired_);
|
|
var segmentRange = _videoJs2['default'].createTimeRanges([[Math.max(currentTime, startOfSegment), startOfSegment + segment.duration]]);
|
|
|
|
return _ranges2['default'].calculateBufferedPercent(segmentRange, buffered);
|
|
}
|
|
|
|
/**
|
|
* Determines what segment request should be made, given current
|
|
* playback state.
|
|
*
|
|
* @param {TimeRanges} buffered - the state of the buffer
|
|
* @param {Object} playlist - the playlist object to fetch segments from
|
|
* @param {Number} currentTime - the playback position in seconds
|
|
* @returns {Object} a segment info object that describes the
|
|
* request that should be made or null if no request is necessary
|
|
*/
|
|
}, {
|
|
key: 'checkBuffer_',
|
|
value: function checkBuffer_(buffered, playlist, currentTime) {
|
|
var currentBuffered = _ranges2['default'].findRange(buffered, currentTime);
|
|
|
|
// There are times when MSE reports the first segment as starting a
|
|
// little after 0-time so add a fudge factor to try and fix those cases
|
|
// or we end up fetching the same first segment over and over
|
|
if (currentBuffered.length === 0 && currentTime === 0) {
|
|
currentBuffered = _ranges2['default'].findRange(buffered, currentTime + _ranges2['default'].TIME_FUDGE_FACTOR);
|
|
}
|
|
|
|
var bufferedTime = undefined;
|
|
var currentBufferedEnd = undefined;
|
|
var timestampOffset = this.sourceUpdater_.timestampOffset();
|
|
var segment = undefined;
|
|
var mediaIndex = undefined;
|
|
|
|
if (!playlist.segments.length) {
|
|
return;
|
|
}
|
|
|
|
if (currentBuffered.length === 0) {
|
|
// find the segment containing currentTime
|
|
mediaIndex = (0, _playlist.getMediaIndexForTime_)(playlist, currentTime + this.timeCorrection_, this.expired_);
|
|
} else {
|
|
// find the segment adjacent to the end of the current
|
|
// buffered region
|
|
currentBufferedEnd = currentBuffered.end(0);
|
|
bufferedTime = Math.max(0, currentBufferedEnd - currentTime);
|
|
|
|
// if the video has not yet played only, and we already have
|
|
// one segment downloaded do nothing
|
|
if (!this.hasPlayed_() && bufferedTime >= 1) {
|
|
return null;
|
|
}
|
|
|
|
// if there is plenty of content buffered, and the video has
|
|
// been played before relax for awhile
|
|
if (this.hasPlayed_() && bufferedTime >= GOAL_BUFFER_LENGTH) {
|
|
return null;
|
|
}
|
|
mediaIndex = (0, _playlist.getMediaIndexForTime_)(playlist, currentBufferedEnd + this.timeCorrection_, this.expired_);
|
|
}
|
|
|
|
if (mediaIndex < 0 || mediaIndex === playlist.segments.length) {
|
|
return null;
|
|
}
|
|
|
|
segment = playlist.segments[mediaIndex];
|
|
var startOfSegment = (0, _playlist.duration)(playlist, playlist.mediaSequence + mediaIndex, this.expired_);
|
|
|
|
// We will need to change timestampOffset of the sourceBuffer if either of
|
|
// the following conditions are true:
|
|
// - The segment.timeline !== this.currentTimeline
|
|
// (we are crossing a discontinuity somehow)
|
|
// - The "timestampOffset" for the start of this segment is less than
|
|
// the currently set timestampOffset
|
|
if (segment.timeline !== this.currentTimeline_ || startOfSegment < this.sourceUpdater_.timestampOffset()) {
|
|
timestampOffset = startOfSegment;
|
|
}
|
|
|
|
return {
|
|
// resolve the segment URL relative to the playlist
|
|
uri: segment.resolvedUri,
|
|
// the segment's mediaIndex at the time it was requested
|
|
mediaIndex: mediaIndex,
|
|
// the segment's playlist
|
|
playlist: playlist,
|
|
// unencrypted bytes of the segment
|
|
bytes: null,
|
|
// when a key is defined for this segment, the encrypted bytes
|
|
encryptedBytes: null,
|
|
// the state of the buffer before a segment is appended will be
|
|
// stored here so that the actual segment duration can be
|
|
// determined after it has been appended
|
|
buffered: null,
|
|
// The target timestampOffset for this segment when we append it
|
|
// to the source buffer
|
|
timestampOffset: timestampOffset,
|
|
// The timeline that the segment is in
|
|
timeline: segment.timeline
|
|
};
|
|
}
|
|
|
|
/**
|
|
* abort all pending xhr requests and null any pending segements
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'abort_',
|
|
value: function abort_() {
|
|
if (this.xhr_) {
|
|
this.xhr_.abort();
|
|
}
|
|
|
|
// clear out the segment being processed
|
|
this.pendingSegment_ = null;
|
|
}
|
|
|
|
/**
|
|
* fill the buffer with segements unless the
|
|
* sourceBuffers are currently updating
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'fillBuffer_',
|
|
value: function fillBuffer_() {
|
|
if (this.sourceUpdater_.updating()) {
|
|
return;
|
|
}
|
|
|
|
// see if we need to begin loading immediately
|
|
var request = this.checkBuffer_(this.sourceUpdater_.buffered(), this.playlist_, this.currentTime_(), this.timestampOffset_);
|
|
|
|
if (!request) {
|
|
return;
|
|
}
|
|
|
|
// Sanity check the segment-index determining logic by calcuating the
|
|
// percentage of the chosen segment that is buffered. If more than 90%
|
|
// of the segment is buffered then fetching it will likely not help in
|
|
// any way
|
|
var percentBuffered = this.getSegmentBufferedPercent_(this.playlist_, request.mediaIndex, this.currentTime_(), this.sourceUpdater_.buffered());
|
|
|
|
if (percentBuffered >= 90) {
|
|
// Increment the timeCorrection_ variable to push the fetcher forward
|
|
// in time and hopefully skip any gaps or flaws in our understanding
|
|
// of the media
|
|
this.incrementTimeCorrection_(this.playlist_.targetDuration);
|
|
|
|
if (!this.paused()) {
|
|
this.fillBuffer_();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
this.loadSegment_(request);
|
|
}
|
|
|
|
/**
|
|
* load a specific segment from a request into the buffer
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'loadSegment_',
|
|
value: function loadSegment_(segmentInfo) {
|
|
var segment = undefined;
|
|
var requestTimeout = undefined;
|
|
var keyXhr = undefined;
|
|
var segmentXhr = undefined;
|
|
var seekable = this.seekable_();
|
|
var currentTime = this.currentTime_();
|
|
var removeToTime = 0;
|
|
|
|
// Chrome has a hard limit of 150mb of
|
|
// buffer and a very conservative "garbage collector"
|
|
// We manually clear out the old buffer to ensure
|
|
// we don't trigger the QuotaExceeded error
|
|
// on the source buffer during subsequent appends
|
|
|
|
// If we have a seekable range use that as the limit for what can be removed safely
|
|
// otherwise remove anything older than 1 minute before the current play head
|
|
if (seekable.length && seekable.start(0) > 0 && seekable.start(0) < currentTime) {
|
|
removeToTime = seekable.start(0);
|
|
} else {
|
|
removeToTime = currentTime - 60;
|
|
}
|
|
|
|
if (removeToTime > 0) {
|
|
this.sourceUpdater_.remove(0, removeToTime);
|
|
}
|
|
|
|
segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
|
|
// Set xhr timeout to 150% of the segment duration to allow us
|
|
// some time to switch renditions in the event of a catastrophic
|
|
// decrease in network performance or a server issue.
|
|
requestTimeout = segment.duration * 1.5 * 1000;
|
|
|
|
if (segment.key) {
|
|
keyXhr = this.hls_.xhr({
|
|
uri: segment.key.resolvedUri,
|
|
responseType: 'arraybuffer',
|
|
withCredentials: this.withCredentials_,
|
|
timeout: requestTimeout
|
|
}, this.handleResponse_.bind(this));
|
|
}
|
|
this.pendingSegment_ = segmentInfo;
|
|
segmentXhr = this.hls_.xhr({
|
|
uri: segmentInfo.uri,
|
|
responseType: 'arraybuffer',
|
|
withCredentials: this.withCredentials_,
|
|
timeout: requestTimeout,
|
|
headers: segmentXhrHeaders(segment)
|
|
}, this.handleResponse_.bind(this));
|
|
|
|
this.xhr_ = {
|
|
keyXhr: keyXhr,
|
|
segmentXhr: segmentXhr,
|
|
abort: function abort() {
|
|
if (this.segmentXhr) {
|
|
// Prevent error handler from running.
|
|
this.segmentXhr.onreadystatechange = null;
|
|
this.segmentXhr.abort();
|
|
this.segmentXhr = null;
|
|
}
|
|
if (this.keyXhr) {
|
|
// Prevent error handler from running.
|
|
this.keyXhr.onreadystatechange = null;
|
|
this.keyXhr.abort();
|
|
this.keyXhr = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
this.state = 'WAITING';
|
|
}
|
|
|
|
/**
|
|
* triggered when a segment response is received
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'handleResponse_',
|
|
value: function handleResponse_(error, request) {
|
|
var segmentInfo = undefined;
|
|
var segment = undefined;
|
|
var keyXhrRequest = undefined;
|
|
var view = undefined;
|
|
|
|
// timeout of previously aborted request
|
|
if (!this.xhr_ || request !== this.xhr_.segmentXhr && request !== this.xhr_.keyXhr) {
|
|
return;
|
|
}
|
|
|
|
segmentInfo = this.pendingSegment_;
|
|
segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
|
|
|
|
// if a request times out, reset bandwidth tracking
|
|
if (request.timedout) {
|
|
this.abort_();
|
|
this.bandwidth = 1;
|
|
this.roundTrip = NaN;
|
|
this.state = 'READY';
|
|
return this.trigger('progress');
|
|
}
|
|
|
|
// trigger an event for other errors
|
|
if (!request.aborted && error) {
|
|
// abort will clear xhr_
|
|
keyXhrRequest = this.xhr_.keyXhr;
|
|
this.abort_();
|
|
this.error({
|
|
status: request.status,
|
|
message: request === keyXhrRequest ? 'HLS key request error at URL: ' + segment.key.uri : 'HLS segment request error at URL: ' + segmentInfo.uri,
|
|
code: 2,
|
|
xhr: request
|
|
});
|
|
this.state = 'READY';
|
|
this.pause();
|
|
return this.trigger('error');
|
|
}
|
|
|
|
// stop processing if the request was aborted
|
|
if (!request.response) {
|
|
this.abort_();
|
|
return;
|
|
}
|
|
|
|
if (request === this.xhr_.segmentXhr) {
|
|
// the segment request is no longer outstanding
|
|
this.xhr_.segmentXhr = null;
|
|
|
|
// calculate the download bandwidth based on segment request
|
|
this.roundTrip = request.roundTripTime;
|
|
this.bandwidth = request.bandwidth;
|
|
this.bytesReceived += request.bytesReceived || 0;
|
|
|
|
if (segment.key) {
|
|
segmentInfo.encryptedBytes = new Uint8Array(request.response);
|
|
} else {
|
|
segmentInfo.bytes = new Uint8Array(request.response);
|
|
}
|
|
}
|
|
|
|
if (request === this.xhr_.keyXhr) {
|
|
keyXhrRequest = this.xhr_.segmentXhr;
|
|
// the key request is no longer outstanding
|
|
this.xhr_.keyXhr = null;
|
|
|
|
if (request.response.byteLength !== 16) {
|
|
this.abort_();
|
|
this.error({
|
|
status: request.status,
|
|
message: 'Invalid HLS key at URL: ' + segment.key.uri,
|
|
code: 2,
|
|
xhr: request
|
|
});
|
|
this.state = 'READY';
|
|
this.pause();
|
|
return this.trigger('error');
|
|
}
|
|
|
|
view = new DataView(request.response);
|
|
segment.key.bytes = new Uint32Array([view.getUint32(0), view.getUint32(4), view.getUint32(8), view.getUint32(12)]);
|
|
|
|
// if the media sequence is greater than 2^32, the IV will be incorrect
|
|
// assuming 10s segments, that would be about 1300 years
|
|
segment.key.iv = segment.key.iv || new Uint32Array([0, 0, 0, segmentInfo.mediaIndex + segmentInfo.playlist.mediaSequence]);
|
|
}
|
|
|
|
if (!this.xhr_.segmentXhr && !this.xhr_.keyXhr) {
|
|
this.xhr_ = null;
|
|
this.processResponse_();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* clear anything that is currently in the buffer and throw it away
|
|
*/
|
|
}, {
|
|
key: 'clearBuffer',
|
|
value: function clearBuffer() {
|
|
if (this.sourceUpdater_ && this.sourceUpdater_.buffered().length) {
|
|
this.sourceUpdater_.remove(0, Infinity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decrypt the segment that is being loaded if necessary
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'processResponse_',
|
|
value: function processResponse_() {
|
|
var segmentInfo = undefined;
|
|
var segment = undefined;
|
|
|
|
this.state = 'DECRYPTING';
|
|
|
|
segmentInfo = this.pendingSegment_;
|
|
segment = segmentInfo.playlist.segments[segmentInfo.mediaIndex];
|
|
|
|
if (segment.key) {
|
|
// this is an encrypted segment
|
|
// incrementally decrypt the segment
|
|
/* eslint-disable no-new, handle-callback-err */
|
|
new _decrypter.Decrypter(segmentInfo.encryptedBytes, segment.key.bytes, segment.key.iv, (function (err, bytes) {
|
|
// err always null
|
|
segmentInfo.bytes = bytes;
|
|
this.handleSegment_();
|
|
}).bind(this));
|
|
/* eslint-enable */
|
|
} else {
|
|
this.handleSegment_();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* append a decrypted segement to the SourceBuffer through a SourceUpdater
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'handleSegment_',
|
|
value: function handleSegment_() {
|
|
var segmentInfo = undefined;
|
|
|
|
this.state = 'APPENDING';
|
|
segmentInfo = this.pendingSegment_;
|
|
segmentInfo.buffered = this.sourceUpdater_.buffered();
|
|
this.currentTimeline_ = segmentInfo.timeline;
|
|
|
|
if (segmentInfo.timestampOffset !== this.sourceUpdater_.timestampOffset()) {
|
|
this.sourceUpdater_.timestampOffset(segmentInfo.timestampOffset);
|
|
}
|
|
|
|
this.sourceUpdater_.appendBuffer(segmentInfo.bytes, this.handleUpdateEnd_.bind(this));
|
|
}
|
|
|
|
/**
|
|
* callback to run when appendBuffer is finished. detects if we are
|
|
* in a good state to do things with the data we got, or if we need
|
|
* to wait for more
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'handleUpdateEnd_',
|
|
value: function handleUpdateEnd_() {
|
|
var segmentInfo = this.pendingSegment_;
|
|
var currentTime = this.currentTime_();
|
|
|
|
this.pendingSegment_ = null;
|
|
|
|
// add segment metadata if it we have gained information during the
|
|
// last append
|
|
this.updateTimeline_(segmentInfo);
|
|
this.trigger('progress');
|
|
|
|
var currentMediaIndex = segmentInfo.mediaIndex;
|
|
|
|
currentMediaIndex += segmentInfo.playlist.mediaSequence - this.playlist_.mediaSequence;
|
|
|
|
var currentBuffered = _ranges2['default'].findRange(this.sourceUpdater_.buffered(), currentTime);
|
|
|
|
// any time an update finishes and the last segment is in the
|
|
// buffer, end the stream. this ensures the "ended" event will
|
|
// fire if playback reaches that point.
|
|
var isEndOfStream = detectEndOfStream(segmentInfo.playlist, this.mediaSource_, currentMediaIndex, currentBuffered);
|
|
|
|
if (isEndOfStream) {
|
|
this.mediaSource_.endOfStream();
|
|
}
|
|
|
|
// when seeking to the beginning of the seekable range, it's
|
|
// possible that imprecise timing information may cause the seek to
|
|
// end up earlier than the start of the range
|
|
// in that case, seek again
|
|
var seekable = this.seekable_();
|
|
var next = _ranges2['default'].findNextRange(this.sourceUpdater_.buffered(), currentTime);
|
|
|
|
if (this.seeking_() && currentBuffered.length === 0) {
|
|
if (seekable.length && currentTime < seekable.start(0)) {
|
|
|
|
if (next.length) {
|
|
_videoJs2['default'].log('tried seeking to', currentTime, 'but that was too early, retrying at', next.start(0));
|
|
this.setCurrentTime_(next.start(0) + _ranges2['default'].TIME_FUDGE_FACTOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 'READY';
|
|
|
|
if (!this.paused()) {
|
|
this.fillBuffer_();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* annotate the segment with any start and end time information
|
|
* added by the media processing
|
|
*
|
|
* @private
|
|
* @param {Object} segmentInfo annotate a segment with time info
|
|
*/
|
|
}, {
|
|
key: 'updateTimeline_',
|
|
value: function updateTimeline_(segmentInfo) {
|
|
var segment = undefined;
|
|
var segmentEnd = undefined;
|
|
var timelineUpdated = undefined;
|
|
var segmentLength = this.playlist_.targetDuration;
|
|
var playlist = segmentInfo.playlist;
|
|
var currentMediaIndex = segmentInfo.mediaIndex;
|
|
|
|
currentMediaIndex += playlist.mediaSequence - this.playlist_.mediaSequence;
|
|
segment = playlist.segments[currentMediaIndex];
|
|
|
|
// Update segment meta-data (duration and end-point) based on timeline
|
|
if (segment && segmentInfo && segmentInfo.playlist.uri === this.playlist_.uri) {
|
|
segmentEnd = _ranges2['default'].findSoleUncommonTimeRangesEnd(segmentInfo.buffered, this.sourceUpdater_.buffered());
|
|
timelineUpdated = updateSegmentMetadata(playlist, currentMediaIndex, segmentEnd);
|
|
segmentLength = segment.duration;
|
|
}
|
|
|
|
// the last segment append must have been entirely in the
|
|
// already buffered time ranges. adjust the timeCorrection
|
|
// offset to fetch forward until we find a segment that adds
|
|
// to the buffered time ranges and improves subsequent media
|
|
// index calculations.
|
|
if (!timelineUpdated) {
|
|
this.incrementTimeCorrection_(segmentLength);
|
|
} else {
|
|
this.timeCorrection_ = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add a number of seconds to the currentTime when determining which
|
|
* segment to fetch in order to force the fetcher to advance in cases
|
|
* where it may get stuck on the same segment due to buffer gaps or
|
|
* missing segment annotation after a rendition switch (especially
|
|
* during a live stream)
|
|
*
|
|
* @private
|
|
* @param {Number} secondsToIncrement number of seconds to add to the
|
|
* timeCorrection_ variable
|
|
*/
|
|
}, {
|
|
key: 'incrementTimeCorrection_',
|
|
value: function incrementTimeCorrection_(secondsToIncrement) {
|
|
// If we have already incremented timeCorrection_ beyond the limit,
|
|
// then stop trying to find a segment, pause fetching, and emit an
|
|
// error event
|
|
if (this.timeCorrection_ >= this.playlist_.targetDuration * 5) {
|
|
this.timeCorrection_ = 0;
|
|
this.pause();
|
|
return this.trigger('error');
|
|
}
|
|
|
|
this.timeCorrection_ += secondsToIncrement;
|
|
}
|
|
}]);
|
|
|
|
return SegmentLoader;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = SegmentLoader;
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./decrypter":5,"./playlist":13,"./ranges":14,"./source-updater":17}],17:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file source-updater.js
|
|
*/
|
|
'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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
/**
|
|
* A queue of callbacks to be serialized and applied when a
|
|
* MediaSource and its associated SourceBuffers are not in the
|
|
* updating state. It is used by the segment loader to update the
|
|
* underlying SourceBuffers when new data is loaded, for instance.
|
|
*
|
|
* @class SourceUpdater
|
|
* @param {MediaSource} mediaSource the MediaSource to create the
|
|
* SourceBuffer from
|
|
* @param {String} mimeType the desired MIME type of the underlying
|
|
* SourceBuffer
|
|
*/
|
|
|
|
var SourceUpdater = (function () {
|
|
function SourceUpdater(mediaSource, mimeType) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, SourceUpdater);
|
|
|
|
var createSourceBuffer = function createSourceBuffer() {
|
|
_this.sourceBuffer_ = mediaSource.addSourceBuffer(mimeType);
|
|
|
|
// run completion handlers and process callbacks as updateend
|
|
// events fire
|
|
_this.sourceBuffer_.addEventListener('updateend', function () {
|
|
var pendingCallback = _this.pendingCallback_;
|
|
|
|
_this.pendingCallback_ = null;
|
|
|
|
if (pendingCallback) {
|
|
pendingCallback();
|
|
}
|
|
});
|
|
_this.sourceBuffer_.addEventListener('updateend', _this.runCallback_.bind(_this));
|
|
|
|
_this.runCallback_();
|
|
};
|
|
|
|
this.callbacks_ = [];
|
|
this.pendingCallback_ = null;
|
|
this.timestampOffset_ = 0;
|
|
this.mediaSource = mediaSource;
|
|
|
|
if (mediaSource.readyState === 'closed') {
|
|
mediaSource.addEventListener('sourceopen', createSourceBuffer);
|
|
} else {
|
|
createSourceBuffer();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aborts the current segment and resets the segment parser.
|
|
*
|
|
* @param {Function} done function to call when done
|
|
* @see http://w3c.github.io/media-source/#widl-SourceBuffer-abort-void
|
|
*/
|
|
|
|
_createClass(SourceUpdater, [{
|
|
key: 'abort',
|
|
value: function abort(done) {
|
|
var _this2 = this;
|
|
|
|
this.queueCallback_(function () {
|
|
_this2.sourceBuffer_.abort();
|
|
}, done);
|
|
}
|
|
|
|
/**
|
|
* Queue an update to append an ArrayBuffer.
|
|
*
|
|
* @param {ArrayBuffer} bytes
|
|
* @param {Function} done the function to call when done
|
|
* @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-appendBuffer-void-ArrayBuffer-data
|
|
*/
|
|
}, {
|
|
key: 'appendBuffer',
|
|
value: function appendBuffer(bytes, done) {
|
|
var _this3 = this;
|
|
|
|
this.queueCallback_(function () {
|
|
_this3.sourceBuffer_.appendBuffer(bytes);
|
|
}, done);
|
|
}
|
|
|
|
/**
|
|
* Indicates what TimeRanges are buffered in the managed SourceBuffer.
|
|
*
|
|
* @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-buffered
|
|
*/
|
|
}, {
|
|
key: 'buffered',
|
|
value: function buffered() {
|
|
if (!this.sourceBuffer_) {
|
|
return _videoJs2['default'].createTimeRanges();
|
|
}
|
|
return this.sourceBuffer_.buffered;
|
|
}
|
|
|
|
/**
|
|
* Queue an update to set the duration.
|
|
*
|
|
* @param {Double} duration what to set the duration to
|
|
* @see http://www.w3.org/TR/media-source/#widl-MediaSource-duration
|
|
*/
|
|
}, {
|
|
key: 'duration',
|
|
value: function duration(_duration) {
|
|
var _this4 = this;
|
|
|
|
this.queueCallback_(function () {
|
|
_this4.sourceBuffer_.duration = _duration;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Queue an update to remove a time range from the buffer.
|
|
*
|
|
* @param {Number} start where to start the removal
|
|
* @param {Number} end where to end the removal
|
|
* @see http://www.w3.org/TR/media-source/#widl-SourceBuffer-remove-void-double-start-unrestricted-double-end
|
|
*/
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(start, end) {
|
|
var _this5 = this;
|
|
|
|
this.queueCallback_(function () {
|
|
_this5.sourceBuffer_.remove(start, end);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* wether the underlying sourceBuffer is updating or not
|
|
*
|
|
* @return {Boolean} the updating status of the SourceBuffer
|
|
*/
|
|
}, {
|
|
key: 'updating',
|
|
value: function updating() {
|
|
return !this.sourceBuffer_ || this.sourceBuffer_.updating;
|
|
}
|
|
|
|
/**
|
|
* Set/get the timestampoffset on the SourceBuffer
|
|
*
|
|
* @return {Number} the timestamp offset
|
|
*/
|
|
}, {
|
|
key: 'timestampOffset',
|
|
value: function timestampOffset(offset) {
|
|
var _this6 = this;
|
|
|
|
if (typeof offset !== 'undefined') {
|
|
this.queueCallback_(function () {
|
|
_this6.sourceBuffer_.timestampOffset = offset;
|
|
});
|
|
this.timestampOffset_ = offset;
|
|
}
|
|
return this.timestampOffset_;
|
|
}
|
|
|
|
/**
|
|
* que a callback to run
|
|
*/
|
|
}, {
|
|
key: 'queueCallback_',
|
|
value: function queueCallback_(callback, done) {
|
|
this.callbacks_.push([callback.bind(this), done]);
|
|
this.runCallback_();
|
|
}
|
|
|
|
/**
|
|
* run a queued callback
|
|
*/
|
|
}, {
|
|
key: 'runCallback_',
|
|
value: function runCallback_() {
|
|
var callbacks = undefined;
|
|
|
|
if (this.sourceBuffer_ && !this.sourceBuffer_.updating && this.callbacks_.length) {
|
|
callbacks = this.callbacks_.shift();
|
|
this.pendingCallback_ = callbacks[1];
|
|
callbacks[0]();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dispose of the source updater and the underlying sourceBuffer
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
if (this.sourceBuffer_ && this.mediaSource.readyState === 'open') {
|
|
this.sourceBuffer_.abort();
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return SourceUpdater;
|
|
})();
|
|
|
|
exports['default'] = SourceUpdater;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],18:[function(require,module,exports){
|
|
/**
|
|
* @file stream.js
|
|
*/
|
|
/**
|
|
* A lightweight readable stream implemention that handles event dispatching.
|
|
*
|
|
* @class Stream
|
|
*/
|
|
'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'); } }
|
|
|
|
var Stream = (function () {
|
|
function Stream() {
|
|
_classCallCheck(this, Stream);
|
|
|
|
this.listeners = {};
|
|
}
|
|
|
|
/**
|
|
* Add a listener for a specified event type.
|
|
*
|
|
* @param {String} type the event name
|
|
* @param {Function} listener the callback to be invoked when an event of
|
|
* the specified type occurs
|
|
*/
|
|
|
|
_createClass(Stream, [{
|
|
key: 'on',
|
|
value: function on(type, listener) {
|
|
if (!this.listeners[type]) {
|
|
this.listeners[type] = [];
|
|
}
|
|
this.listeners[type].push(listener);
|
|
}
|
|
|
|
/**
|
|
* Remove a listener for a specified event type.
|
|
*
|
|
* @param {String} type the event name
|
|
* @param {Function} listener a function previously registered for this
|
|
* type of event through `on`
|
|
* @return {Boolean} if we could turn it off or not
|
|
*/
|
|
}, {
|
|
key: 'off',
|
|
value: function off(type, listener) {
|
|
var index = undefined;
|
|
|
|
if (!this.listeners[type]) {
|
|
return false;
|
|
}
|
|
index = this.listeners[type].indexOf(listener);
|
|
this.listeners[type].splice(index, 1);
|
|
return index > -1;
|
|
}
|
|
|
|
/**
|
|
* Trigger an event of the specified type on this stream. Any additional
|
|
* arguments to this function are passed as parameters to event listeners.
|
|
*
|
|
* @param {String} type the event name
|
|
*/
|
|
}, {
|
|
key: 'trigger',
|
|
value: function trigger(type) {
|
|
var callbacks = undefined;
|
|
var i = undefined;
|
|
var length = undefined;
|
|
var args = undefined;
|
|
|
|
callbacks = this.listeners[type];
|
|
if (!callbacks) {
|
|
return;
|
|
}
|
|
// Slicing the arguments on every invocation of this method
|
|
// can add a significant amount of overhead. Avoid the
|
|
// intermediate object creation for the common case of a
|
|
// single callback argument
|
|
if (arguments.length === 2) {
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].call(this, arguments[1]);
|
|
}
|
|
} else {
|
|
args = Array.prototype.slice.call(arguments, 1);
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys the stream and cleans up.
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
this.listeners = {};
|
|
}
|
|
|
|
/**
|
|
* Forwards all `data` events on this stream to the destination stream. The
|
|
* destination stream should provide a method `push` to receive the data
|
|
* events as they arrive.
|
|
*
|
|
* @param {Stream} destination the stream that will receive all `data` events
|
|
* @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
|
|
*/
|
|
}, {
|
|
key: 'pipe',
|
|
value: function pipe(destination) {
|
|
this.on('data', function (data) {
|
|
destination.push(data);
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Stream;
|
|
})();
|
|
|
|
exports['default'] = Stream;
|
|
module.exports = exports['default'];
|
|
},{}],19:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file xhr.js
|
|
*/
|
|
|
|
/**
|
|
* A wrapper for videojs.xhr that tracks bandwidth.
|
|
*
|
|
* @param {Object} options options for the XHR
|
|
* @param {Function} callback the callback to call when done
|
|
* @return {Request} the xhr request that is going to be made
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var xhrFactory = function xhrFactory() {
|
|
var xhr = function XhrFunction(options, callback) {
|
|
// Add a default timeout for all hls requests
|
|
options = (0, _videoJs.mergeOptions)({
|
|
timeout: 45e3
|
|
}, options);
|
|
|
|
// Allow an optional user-specified function to modify the option
|
|
// object before we construct the xhr request
|
|
if (XhrFunction.beforeRequest && typeof XhrFunction.beforeRequest === 'function') {
|
|
var newOptions = XhrFunction.beforeRequest(options);
|
|
|
|
if (newOptions) {
|
|
options = newOptions;
|
|
}
|
|
}
|
|
|
|
var request = (0, _videoJs.xhr)(options, function (error, response) {
|
|
if (!error && request.response) {
|
|
request.responseTime = new Date().getTime();
|
|
request.roundTripTime = request.responseTime - request.requestTime;
|
|
request.bytesReceived = request.response.byteLength || request.response.length;
|
|
if (!request.bandwidth) {
|
|
request.bandwidth = Math.floor(request.bytesReceived / request.roundTripTime * 8 * 1000);
|
|
}
|
|
}
|
|
|
|
// videojs.xhr now uses a specific code
|
|
// on the error object to signal that a request has
|
|
// timed out errors of setting a boolean on the request object
|
|
if (error || request.timedout) {
|
|
request.timedout = request.timedout || error.code === 'ETIMEDOUT';
|
|
} else {
|
|
request.timedout = false;
|
|
}
|
|
|
|
// videojs.xhr no longer considers status codes outside of 200 and 0
|
|
// (for file uris) to be errors, but the old XHR did, so emulate that
|
|
// behavior. Status 206 may be used in response to byterange requests.
|
|
if (!error && response.statusCode !== 200 && response.statusCode !== 206 && response.statusCode !== 0) {
|
|
error = new Error('XHR Failed with a response of: ' + (request && (request.response || request.responseText)));
|
|
}
|
|
|
|
callback(error, request);
|
|
});
|
|
|
|
request.requestTime = new Date().getTime();
|
|
return request;
|
|
};
|
|
|
|
return xhr;
|
|
};
|
|
|
|
exports['default'] = xhrFactory;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],20:[function(require,module,exports){
|
|
|
|
},{}],21:[function(require,module,exports){
|
|
(function (global){
|
|
var topLevel = typeof global !== 'undefined' ? global :
|
|
typeof window !== 'undefined' ? window : {}
|
|
var minDoc = require('min-document');
|
|
|
|
if (typeof document !== 'undefined') {
|
|
module.exports = document;
|
|
} else {
|
|
var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
|
|
|
|
if (!doccy) {
|
|
doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
|
|
}
|
|
|
|
module.exports = doccy;
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"min-document":20}],22:[function(require,module,exports){
|
|
/*
|
|
* pkcs7.pad
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var PADDING;
|
|
|
|
/**
|
|
* Returns a new Uint8Array that is padded with PKCS#7 padding.
|
|
* @param plaintext {Uint8Array} the input bytes before encryption
|
|
* @return {Uint8Array} the padded bytes
|
|
* @see http://tools.ietf.org/html/rfc5652
|
|
*/
|
|
module.exports = function pad(plaintext) {
|
|
var padding = PADDING[(plaintext.byteLength % 16) || 0],
|
|
result = new Uint8Array(plaintext.byteLength + padding.length);
|
|
result.set(plaintext);
|
|
result.set(padding, plaintext.byteLength);
|
|
return result;
|
|
};
|
|
|
|
// pre-define the padding values
|
|
PADDING = [
|
|
[16, 16, 16, 16,
|
|
16, 16, 16, 16,
|
|
16, 16, 16, 16,
|
|
16, 16, 16, 16],
|
|
|
|
[15, 15, 15, 15,
|
|
15, 15, 15, 15,
|
|
15, 15, 15, 15,
|
|
15, 15, 15],
|
|
|
|
[14, 14, 14, 14,
|
|
14, 14, 14, 14,
|
|
14, 14, 14, 14,
|
|
14, 14],
|
|
|
|
[13, 13, 13, 13,
|
|
13, 13, 13, 13,
|
|
13, 13, 13, 13,
|
|
13],
|
|
|
|
[12, 12, 12, 12,
|
|
12, 12, 12, 12,
|
|
12, 12, 12, 12],
|
|
|
|
[11, 11, 11, 11,
|
|
11, 11, 11, 11,
|
|
11, 11, 11],
|
|
|
|
[10, 10, 10, 10,
|
|
10, 10, 10, 10,
|
|
10, 10],
|
|
|
|
[9, 9, 9, 9,
|
|
9, 9, 9, 9,
|
|
9],
|
|
|
|
[8, 8, 8, 8,
|
|
8, 8, 8, 8],
|
|
|
|
[7, 7, 7, 7,
|
|
7, 7, 7],
|
|
|
|
[6, 6, 6, 6,
|
|
6, 6],
|
|
|
|
[5, 5, 5, 5,
|
|
5],
|
|
|
|
[4, 4, 4, 4],
|
|
|
|
[3, 3, 3],
|
|
|
|
[2, 2],
|
|
|
|
[1]
|
|
];
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
/*
|
|
* pkcs7
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.pad = require('./pad.js');
|
|
exports.unpad = require('./unpad.js');
|
|
|
|
},{"./pad.js":22,"./unpad.js":24}],24:[function(require,module,exports){
|
|
/*
|
|
* pkcs7.unpad
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Returns the subarray of a Uint8Array without PKCS#7 padding.
|
|
* @param padded {Uint8Array} unencrypted bytes that have been padded
|
|
* @return {Uint8Array} the unpadded bytes
|
|
* @see http://tools.ietf.org/html/rfc5652
|
|
*/
|
|
module.exports = function unpad(padded) {
|
|
return padded.subarray(0, padded.byteLength - padded[padded.byteLength - 1]);
|
|
};
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file add-text-track-data.js
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
/**
|
|
* Define properties on a cue for backwards compatability,
|
|
* but warn the user that the way that they are using it
|
|
* is depricated and will be removed at a later date.
|
|
*
|
|
* @param {Cue} cue the cue to add the properties on
|
|
* @private
|
|
*/
|
|
var deprecateOldCue = function deprecateOldCue(cue) {
|
|
Object.defineProperties(cue.frame, {
|
|
id: {
|
|
get: function get() {
|
|
_videoJs2['default'].log.warn('cue.frame.id is deprecated. Use cue.value.key instead.');
|
|
return cue.value.key;
|
|
}
|
|
},
|
|
value: {
|
|
get: function get() {
|
|
_videoJs2['default'].log.warn('cue.frame.value is deprecated. Use cue.value.data instead.');
|
|
return cue.value.data;
|
|
}
|
|
},
|
|
privateData: {
|
|
get: function get() {
|
|
_videoJs2['default'].log.warn('cue.frame.privateData is deprecated. Use cue.value.data instead.');
|
|
return cue.value.data;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Add text track data to a source handler given the captions and
|
|
* metadata from the buffer.
|
|
*
|
|
* @param {Object} sourceHandler the flash or virtual source buffer
|
|
* @param {Array} captionArray an array of caption data
|
|
* @param {Array} cue an array of meta data
|
|
* @private
|
|
*/
|
|
var addTextTrackData = function addTextTrackData(sourceHandler, captionArray, metadataArray) {
|
|
var Cue = window.WebKitDataCue || window.VTTCue;
|
|
|
|
if (captionArray) {
|
|
captionArray.forEach(function (caption) {
|
|
this.inbandTextTrack_.addCue(new Cue(caption.startTime + this.timestampOffset, caption.endTime + this.timestampOffset, caption.text));
|
|
}, sourceHandler);
|
|
}
|
|
|
|
if (metadataArray) {
|
|
metadataArray.forEach(function (metadata) {
|
|
var time = metadata.cueTime + this.timestampOffset;
|
|
|
|
metadata.frames.forEach(function (frame) {
|
|
var cue = new Cue(time, time, frame.value || frame.url || frame.data || '');
|
|
|
|
cue.frame = frame;
|
|
cue.value = frame;
|
|
deprecateOldCue(cue);
|
|
this.metadataTrack_.addCue(cue);
|
|
}, this);
|
|
}, sourceHandler);
|
|
}
|
|
};
|
|
|
|
exports['default'] = addTextTrackData;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],26:[function(require,module,exports){
|
|
/**
|
|
* @file codec-utils.js
|
|
*/
|
|
|
|
/**
|
|
* Check if a codec string refers to an audio codec.
|
|
*
|
|
* @param {String} codec codec string to check
|
|
* @return {Boolean} if this is an audio codec
|
|
* @private
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
var isAudioCodec = function isAudioCodec(codec) {
|
|
return (/mp4a\.\d+.\d+/i.test(codec)
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Check if a codec string refers to a video codec.
|
|
*
|
|
* @param {String} codec codec string to check
|
|
* @return {Boolean} if this is a video codec
|
|
* @private
|
|
*/
|
|
var isVideoCodec = function isVideoCodec(codec) {
|
|
return (/avc1\.[\da-f]+/i.test(codec)
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Parse a content type header into a type and parameters
|
|
* object
|
|
*
|
|
* @param {String} type the content type header
|
|
* @return {Object} the parsed content-type
|
|
* @private
|
|
*/
|
|
var parseContentType = function parseContentType(type) {
|
|
var object = { type: '', parameters: {} };
|
|
var parameters = type.trim().split(';');
|
|
|
|
// first parameter should always be content-type
|
|
object.type = parameters.shift().trim();
|
|
parameters.forEach(function (parameter) {
|
|
var pair = parameter.trim().split('=');
|
|
|
|
if (pair.length > 1) {
|
|
var _name = pair[0].replace(/"/g, '').trim();
|
|
var value = pair[1].replace(/"/g, '').trim();
|
|
|
|
object.parameters[_name] = value;
|
|
}
|
|
});
|
|
|
|
return object;
|
|
};
|
|
|
|
exports['default'] = {
|
|
isAudioCodec: isAudioCodec,
|
|
parseContentType: parseContentType,
|
|
isVideoCodec: isVideoCodec
|
|
};
|
|
module.exports = exports['default'];
|
|
},{}],27:[function(require,module,exports){
|
|
/**
|
|
* @file create-text-tracks-if-necessary.js
|
|
*/
|
|
|
|
/**
|
|
* Create text tracks on video.js if they exist on a segment.
|
|
*
|
|
* @param {Object} sourceBuffer the VSB or FSB
|
|
* @param {Object} mediaSource the HTML or Flash media source
|
|
* @param {Object} segment the segment that may contain the text track
|
|
* @private
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
var createTextTracksIfNecessary = function createTextTracksIfNecessary(sourceBuffer, mediaSource, segment) {
|
|
// create an in-band caption track if one is present in the segment
|
|
if (segment.captions && segment.captions.length && !sourceBuffer.inbandTextTrack_) {
|
|
sourceBuffer.inbandTextTrack_ = mediaSource.player_.addTextTrack('captions', 'cc1');
|
|
}
|
|
|
|
if (segment.metadata && segment.metadata.length && !sourceBuffer.metadataTrack_) {
|
|
sourceBuffer.metadataTrack_ = mediaSource.player_.addTextTrack('metadata', 'Timed Metadata');
|
|
sourceBuffer.metadataTrack_.inBandMetadataTrackDispatchType = segment.metadata.dispatchType;
|
|
}
|
|
};
|
|
|
|
exports['default'] = createTextTracksIfNecessary;
|
|
module.exports = exports['default'];
|
|
},{}],28:[function(require,module,exports){
|
|
/**
|
|
* @file flash-constants.js
|
|
*/
|
|
/**
|
|
* The maximum size in bytes for append operations to the video.js
|
|
* SWF. Calling through to Flash blocks and can be expensive so
|
|
* tuning this parameter may improve playback on slower
|
|
* systems. There are two factors to consider:
|
|
* - Each interaction with the SWF must be quick or you risk dropping
|
|
* video frames. To maintain 60fps for the rest of the page, each append
|
|
* must not take longer than 16ms. Given the likelihood that the page
|
|
* will be executing more javascript than just playback, you probably
|
|
* want to aim for less than 8ms. We aim for just 4ms.
|
|
* - Bigger appends significantly increase throughput. The total number of
|
|
* bytes over time delivered to the SWF must exceed the video bitrate or
|
|
* playback will stall.
|
|
*
|
|
* We adaptively tune the size of appends to give the best throughput
|
|
* possible given the performance of the system. To do that we try to append
|
|
* as much as possible in TIME_PER_TICK and while tuning the size of appends
|
|
* dynamically so that we only append about 4-times in that 4ms span.
|
|
*
|
|
* The reason we try to keep the number of appends around four is due to
|
|
* externalities such as Flash load and garbage collection that are highly
|
|
* variable and having 4 iterations allows us to exit the loop early if
|
|
* an iteration takes longer than expected.
|
|
*
|
|
* @private
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var flashConstants = {
|
|
TIME_BETWEEN_TICKS: Math.floor(1000 / 480),
|
|
TIME_PER_TICK: Math.floor(1000 / 240),
|
|
// 1kb
|
|
BYTES_PER_CHUNK: 1 * 1024,
|
|
MIN_CHUNK: 1024,
|
|
MAX_CHUNK: 1024 * 1024
|
|
};
|
|
|
|
exports["default"] = flashConstants;
|
|
module.exports = exports["default"];
|
|
},{}],29:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file flash-media-source.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _flashSourceBuffer = require('./flash-source-buffer');
|
|
|
|
var _flashSourceBuffer2 = _interopRequireDefault(_flashSourceBuffer);
|
|
|
|
var _flashConstants = require('./flash-constants');
|
|
|
|
var _flashConstants2 = _interopRequireDefault(_flashConstants);
|
|
|
|
var _codecUtils = require('./codec-utils');
|
|
|
|
/**
|
|
* A flash implmentation of HTML MediaSources and a polyfill
|
|
* for browsers that don't support native or HTML MediaSources..
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource
|
|
* @class FlashMediaSource
|
|
* @extends videojs.EventTarget
|
|
*/
|
|
|
|
var FlashMediaSource = (function (_videojs$EventTarget) {
|
|
_inherits(FlashMediaSource, _videojs$EventTarget);
|
|
|
|
function FlashMediaSource() {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, FlashMediaSource);
|
|
|
|
_get(Object.getPrototypeOf(FlashMediaSource.prototype), 'constructor', this).call(this);
|
|
this.sourceBuffers = [];
|
|
this.readyState = 'closed';
|
|
|
|
this.on(['sourceopen', 'webkitsourceopen'], function (event) {
|
|
// find the swf where we will push media data
|
|
_this.swfObj = document.getElementById(event.swfId);
|
|
_this.player_ = (0, _videoJs2['default'])(_this.swfObj.parentNode);
|
|
_this.tech_ = _this.swfObj.tech;
|
|
_this.readyState = 'open';
|
|
|
|
_this.tech_.on('seeking', function () {
|
|
var i = _this.sourceBuffers.length;
|
|
|
|
while (i--) {
|
|
_this.sourceBuffers[i].abort();
|
|
}
|
|
});
|
|
|
|
// trigger load events
|
|
if (_this.swfObj) {
|
|
_this.swfObj.vjs_load();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Set or return the presentation duration.
|
|
*
|
|
* @param {Double} value the duration of the media in seconds
|
|
* @param {Double} the current presentation duration
|
|
* @link http://www.w3.org/TR/media-source/#widl-MediaSource-duration
|
|
*/
|
|
|
|
/**
|
|
* We have this function so that the html and flash interfaces
|
|
* are the same.
|
|
*
|
|
* @private
|
|
*/
|
|
|
|
_createClass(FlashMediaSource, [{
|
|
key: 'addSeekableRange_',
|
|
value: function addSeekableRange_() {}
|
|
// intentional no-op
|
|
|
|
/**
|
|
* Create a new flash source buffer and add it to our flash media source.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource/addSourceBuffer
|
|
* @param {String} type the content-type of the source
|
|
* @return {Object} the flash source buffer
|
|
*/
|
|
|
|
}, {
|
|
key: 'addSourceBuffer',
|
|
value: function addSourceBuffer(type) {
|
|
var parsedType = (0, _codecUtils.parseContentType)(type);
|
|
var sourceBuffer = undefined;
|
|
|
|
// if this is an FLV type, we'll push data to flash
|
|
if (parsedType.type === 'video/mp2t') {
|
|
// Flash source buffers
|
|
sourceBuffer = new _flashSourceBuffer2['default'](this);
|
|
} else {
|
|
throw new Error('NotSupportedError (Video.js)');
|
|
}
|
|
|
|
this.sourceBuffers.push(sourceBuffer);
|
|
return sourceBuffer;
|
|
}
|
|
|
|
/**
|
|
* Signals the end of the stream.
|
|
*
|
|
* @link https://w3c.github.io/media-source/#widl-MediaSource-endOfStream-void-EndOfStreamError-error
|
|
* @param {String=} error Signals that a playback error
|
|
* has occurred. If specified, it must be either "network" or
|
|
* "decode".
|
|
*/
|
|
}, {
|
|
key: 'endOfStream',
|
|
value: function endOfStream(error) {
|
|
if (error === 'network') {
|
|
// MEDIA_ERR_NETWORK
|
|
this.tech_.error(2);
|
|
} else if (error === 'decode') {
|
|
// MEDIA_ERR_DECODE
|
|
this.tech_.error(3);
|
|
}
|
|
if (this.readyState !== 'ended') {
|
|
this.readyState = 'ended';
|
|
this.swfObj.vjs_endOfStream();
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return FlashMediaSource;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = FlashMediaSource;
|
|
try {
|
|
Object.defineProperty(FlashMediaSource.prototype, 'duration', {
|
|
/**
|
|
* Return the presentation duration.
|
|
*
|
|
* @return {Double} the duration of the media in seconds
|
|
* @link http://www.w3.org/TR/media-source/#widl-MediaSource-duration
|
|
*/
|
|
get: function get() {
|
|
if (!this.swfObj) {
|
|
return NaN;
|
|
}
|
|
// get the current duration from the SWF
|
|
return this.swfObj.vjs_getProperty('duration');
|
|
},
|
|
/**
|
|
* Set the presentation duration.
|
|
*
|
|
* @param {Double} value the duration of the media in seconds
|
|
* @return {Double} the duration of the media in seconds
|
|
* @link http://www.w3.org/TR/media-source/#widl-MediaSource-duration
|
|
*/
|
|
set: function set(value) {
|
|
var i = undefined;
|
|
var oldDuration = this.swfObj.vjs_getProperty('duration');
|
|
|
|
this.swfObj.vjs_setProperty('duration', value);
|
|
|
|
if (value < oldDuration) {
|
|
// In MSE, this triggers the range removal algorithm which causes
|
|
// an update to occur
|
|
for (i = 0; i < this.sourceBuffers.length; i++) {
|
|
this.sourceBuffers[i].remove(value, oldDuration);
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
});
|
|
} catch (e) {
|
|
// IE8 throws if defineProperty is called on a non-DOM node. We
|
|
// don't support IE8 but we shouldn't throw an error if loaded
|
|
// there.
|
|
FlashMediaSource.prototype.duration = NaN;
|
|
}
|
|
|
|
for (var property in _flashConstants2['default']) {
|
|
FlashMediaSource[property] = _flashConstants2['default'][property];
|
|
}
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./codec-utils":26,"./flash-constants":28,"./flash-source-buffer":30}],30:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file flash-source-buffer.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _muxJs = require('mux.js');
|
|
|
|
var _muxJs2 = _interopRequireDefault(_muxJs);
|
|
|
|
var _removeCuesFromTrack = require('./remove-cues-from-track');
|
|
|
|
var _removeCuesFromTrack2 = _interopRequireDefault(_removeCuesFromTrack);
|
|
|
|
var _createTextTracksIfNecessary = require('./create-text-tracks-if-necessary');
|
|
|
|
var _createTextTracksIfNecessary2 = _interopRequireDefault(_createTextTracksIfNecessary);
|
|
|
|
var _addTextTrackData = require('./add-text-track-data');
|
|
|
|
var _addTextTrackData2 = _interopRequireDefault(_addTextTrackData);
|
|
|
|
var _flashConstants = require('./flash-constants');
|
|
|
|
var _flashConstants2 = _interopRequireDefault(_flashConstants);
|
|
|
|
/**
|
|
* A wrapper around the setTimeout function that uses
|
|
* the flash constant time between ticks value.
|
|
*
|
|
* @param {Function} func the function callback to run
|
|
* @private
|
|
*/
|
|
var scheduleTick = function scheduleTick(func) {
|
|
// Chrome doesn't invoke requestAnimationFrame callbacks
|
|
// in background tabs, so use setTimeout.
|
|
window.setTimeout(func, _flashConstants2['default'].TIME_BETWEEN_TICKS);
|
|
};
|
|
|
|
/**
|
|
* Round a number to a specified number of places much like
|
|
* toFixed but return a number instead of a string representation.
|
|
*
|
|
* @param {Number} num A number
|
|
* @param {Number} places The number of decimal places which to
|
|
* round
|
|
* @private
|
|
*/
|
|
var toDecimalPlaces = function toDecimalPlaces(num, places) {
|
|
if (typeof places !== 'number' || places < 0) {
|
|
places = 0;
|
|
}
|
|
|
|
var scale = Math.pow(10, places);
|
|
|
|
return Math.round(num * scale) / scale;
|
|
};
|
|
|
|
/**
|
|
* A SourceBuffer implementation for Flash rather than HTML.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource
|
|
* @param {Object} mediaSource the flash media source
|
|
* @class FlashSourceBuffer
|
|
* @extends videojs.EventTarget
|
|
*/
|
|
|
|
var FlashSourceBuffer = (function (_videojs$EventTarget) {
|
|
_inherits(FlashSourceBuffer, _videojs$EventTarget);
|
|
|
|
function FlashSourceBuffer(mediaSource) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, FlashSourceBuffer);
|
|
|
|
_get(Object.getPrototypeOf(FlashSourceBuffer.prototype), 'constructor', this).call(this);
|
|
var encodedHeader = undefined;
|
|
|
|
// Start off using the globally defined value but refine
|
|
// as we append data into flash
|
|
this.chunkSize_ = _flashConstants2['default'].BYTES_PER_CHUNK;
|
|
|
|
// byte arrays queued to be appended
|
|
this.buffer_ = [];
|
|
|
|
// the total number of queued bytes
|
|
this.bufferSize_ = 0;
|
|
|
|
// to be able to determine the correct position to seek to, we
|
|
// need to retain information about the mapping between the
|
|
// media timeline and PTS values
|
|
this.basePtsOffset_ = NaN;
|
|
|
|
this.mediaSource = mediaSource;
|
|
|
|
// indicates whether the asynchronous continuation of an operation
|
|
// is still being processed
|
|
// see https://w3c.github.io/media-source/#widl-SourceBuffer-updating
|
|
this.updating = false;
|
|
this.timestampOffset_ = 0;
|
|
|
|
// TS to FLV transmuxer
|
|
this.segmentParser_ = new _muxJs2['default'].flv.Transmuxer();
|
|
this.segmentParser_.on('data', this.receiveBuffer_.bind(this));
|
|
encodedHeader = window.btoa(String.fromCharCode.apply(null, Array.prototype.slice.call(this.segmentParser_.getFlvHeader())));
|
|
this.mediaSource.swfObj.vjs_appendBuffer(encodedHeader);
|
|
|
|
Object.defineProperty(this, 'timestampOffset', {
|
|
get: function get() {
|
|
return this.timestampOffset_;
|
|
},
|
|
set: function set(val) {
|
|
if (typeof val === 'number' && val >= 0) {
|
|
this.timestampOffset_ = val;
|
|
this.segmentParser_ = new _muxJs2['default'].flv.Transmuxer();
|
|
this.segmentParser_.on('data', this.receiveBuffer_.bind(this));
|
|
// We have to tell flash to expect a discontinuity
|
|
this.mediaSource.swfObj.vjs_discontinuity();
|
|
// the media <-> PTS mapping must be re-established after
|
|
// the discontinuity
|
|
this.basePtsOffset_ = NaN;
|
|
}
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(this, 'buffered', {
|
|
get: function get() {
|
|
if (!this.mediaSource || !this.mediaSource.swfObj || !('vjs_getProperty' in this.mediaSource.swfObj)) {
|
|
return _videoJs2['default'].createTimeRange();
|
|
}
|
|
|
|
var buffered = this.mediaSource.swfObj.vjs_getProperty('buffered');
|
|
|
|
if (buffered && buffered.length) {
|
|
buffered[0][0] = toDecimalPlaces(buffered[0][0], 3);
|
|
buffered[0][1] = toDecimalPlaces(buffered[0][1], 3);
|
|
}
|
|
return _videoJs2['default'].createTimeRanges(buffered);
|
|
}
|
|
});
|
|
|
|
// On a seek we remove all text track data since flash has no concept
|
|
// of a buffered-range and everything else is reset on seek
|
|
this.mediaSource.player_.on('seeked', function () {
|
|
(0, _removeCuesFromTrack2['default'])(0, Infinity, _this.metadataTrack_);
|
|
(0, _removeCuesFromTrack2['default'])(0, Infinity, _this.inbandTextTrack_);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Append bytes to the sourcebuffers buffer, in this case we
|
|
* have to append it to swf object.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/appendBuffer
|
|
* @param {Array} bytes
|
|
*/
|
|
|
|
_createClass(FlashSourceBuffer, [{
|
|
key: 'appendBuffer',
|
|
value: function appendBuffer(bytes) {
|
|
var _this2 = this;
|
|
|
|
var error = undefined;
|
|
var chunk = 512 * 1024;
|
|
var i = 0;
|
|
|
|
if (this.updating) {
|
|
error = new Error('SourceBuffer.append() cannot be called ' + 'while an update is in progress');
|
|
error.name = 'InvalidStateError';
|
|
error.code = 11;
|
|
throw error;
|
|
}
|
|
|
|
this.updating = true;
|
|
this.mediaSource.readyState = 'open';
|
|
this.trigger({ type: 'update' });
|
|
|
|
// this is here to use recursion
|
|
var chunkInData = function chunkInData() {
|
|
_this2.segmentParser_.push(bytes.subarray(i, i + chunk));
|
|
i += chunk;
|
|
if (i < bytes.byteLength) {
|
|
scheduleTick(chunkInData);
|
|
} else {
|
|
scheduleTick(_this2.segmentParser_.flush.bind(_this2.segmentParser_));
|
|
}
|
|
};
|
|
|
|
chunkInData();
|
|
}
|
|
|
|
/**
|
|
* Reset the parser and remove any data queued to be sent to the SWF.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/abort
|
|
*/
|
|
}, {
|
|
key: 'abort',
|
|
value: function abort() {
|
|
this.buffer_ = [];
|
|
this.bufferSize_ = 0;
|
|
this.mediaSource.swfObj.vjs_abort();
|
|
|
|
// report any outstanding updates have ended
|
|
if (this.updating) {
|
|
this.updating = false;
|
|
this.trigger({ type: 'updateend' });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flash cannot remove ranges already buffered in the NetStream
|
|
* but seeking clears the buffer entirely. For most purposes,
|
|
* having this operation act as a no-op is acceptable.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/remove
|
|
* @param {Double} start start of the section to remove
|
|
* @param {Double} end end of the section to remove
|
|
*/
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(start, end) {
|
|
(0, _removeCuesFromTrack2['default'])(start, end, this.metadataTrack_);
|
|
(0, _removeCuesFromTrack2['default'])(start, end, this.inbandTextTrack_);
|
|
this.trigger({ type: 'update' });
|
|
this.trigger({ type: 'updateend' });
|
|
}
|
|
|
|
/**
|
|
* Receive a buffer from the flv.
|
|
*
|
|
* @param {Object} segment
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'receiveBuffer_',
|
|
value: function receiveBuffer_(segment) {
|
|
var _this3 = this;
|
|
|
|
// create an in-band caption track if one is present in the segment
|
|
(0, _createTextTracksIfNecessary2['default'])(this, this.mediaSource, segment);
|
|
(0, _addTextTrackData2['default'])(this, segment.captions, segment.metadata);
|
|
|
|
// Do this asynchronously since convertTagsToData_ can be time consuming
|
|
scheduleTick(function () {
|
|
var flvBytes = _this3.convertTagsToData_(segment);
|
|
|
|
if (_this3.buffer_.length === 0) {
|
|
scheduleTick(_this3.processBuffer_.bind(_this3));
|
|
}
|
|
|
|
if (flvBytes) {
|
|
_this3.buffer_.push(flvBytes);
|
|
_this3.bufferSize_ += flvBytes.byteLength;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Append a portion of the current buffer to the SWF.
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'processBuffer_',
|
|
value: function processBuffer_() {
|
|
var chunk = undefined;
|
|
var i = undefined;
|
|
var length = undefined;
|
|
var binary = undefined;
|
|
var b64str = undefined;
|
|
var startByte = 0;
|
|
var appendIterations = 0;
|
|
var startTime = +new Date();
|
|
var appendTime = undefined;
|
|
|
|
if (!this.buffer_.length) {
|
|
if (this.updating !== false) {
|
|
this.updating = false;
|
|
this.trigger({ type: 'updateend' });
|
|
}
|
|
// do nothing if the buffer is empty
|
|
return;
|
|
}
|
|
|
|
do {
|
|
appendIterations++;
|
|
// concatenate appends up to the max append size
|
|
chunk = this.buffer_[0].subarray(startByte, startByte + this.chunkSize_);
|
|
|
|
// requeue any bytes that won't make it this round
|
|
if (chunk.byteLength < this.chunkSize_ || this.buffer_[0].byteLength === startByte + this.chunkSize_) {
|
|
startByte = 0;
|
|
this.buffer_.shift();
|
|
} else {
|
|
startByte += this.chunkSize_;
|
|
}
|
|
|
|
this.bufferSize_ -= chunk.byteLength;
|
|
|
|
// base64 encode the bytes
|
|
binary = '';
|
|
length = chunk.byteLength;
|
|
for (i = 0; i < length; i++) {
|
|
binary += String.fromCharCode(chunk[i]);
|
|
}
|
|
b64str = window.btoa(binary);
|
|
|
|
// bypass normal ExternalInterface calls and pass xml directly
|
|
// IE can be slow by default
|
|
this.mediaSource.swfObj.CallFunction('<invoke name="vjs_appendBuffer"' + 'returntype="javascript"><arguments><string>' + b64str + '</string></arguments></invoke>');
|
|
appendTime = new Date() - startTime;
|
|
} while (this.buffer_.length && appendTime < _flashConstants2['default'].TIME_PER_TICK);
|
|
|
|
if (this.buffer_.length && startByte) {
|
|
this.buffer_[0] = this.buffer_[0].subarray(startByte);
|
|
}
|
|
|
|
if (appendTime >= _flashConstants2['default'].TIME_PER_TICK) {
|
|
// We want to target 4 iterations per time-slot so that gives us
|
|
// room to adjust to changes in Flash load and other externalities
|
|
// such as garbage collection while still maximizing throughput
|
|
this.chunkSize_ = Math.floor(this.chunkSize_ * (appendIterations / 4));
|
|
}
|
|
|
|
// We also make sure that the chunk-size doesn't drop below 1KB or
|
|
// go above 1MB as a sanity check
|
|
this.chunkSize_ = Math.max(_flashConstants2['default'].MIN_CHUNK, Math.min(this.chunkSize_, _flashConstants2['default'].MAX_CHUNK));
|
|
|
|
// schedule another append if necessary
|
|
if (this.bufferSize_ !== 0) {
|
|
scheduleTick(this.processBuffer_.bind(this));
|
|
} else {
|
|
this.updating = false;
|
|
this.trigger({ type: 'updateend' });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Turns an array of flv tags into a Uint8Array representing the
|
|
* flv data. Also removes any tags that are before the current
|
|
* time so that playback begins at or slightly after the right
|
|
* place on a seek
|
|
*
|
|
* @private
|
|
* @param {Object} segmentData object of segment data
|
|
*/
|
|
}, {
|
|
key: 'convertTagsToData_',
|
|
value: function convertTagsToData_(segmentData) {
|
|
var segmentByteLength = 0;
|
|
var tech = this.mediaSource.tech_;
|
|
var targetPts = 0;
|
|
var i = undefined;
|
|
var j = undefined;
|
|
var segment = undefined;
|
|
var filteredTags = [];
|
|
var tags = this.getOrderedTags_(segmentData);
|
|
|
|
// Establish the media timeline to PTS translation if we don't
|
|
// have one already
|
|
if (isNaN(this.basePtsOffset_) && tags.length) {
|
|
this.basePtsOffset_ = tags[0].pts;
|
|
}
|
|
|
|
// Trim any tags that are before the end of the end of
|
|
// the current buffer
|
|
if (tech.buffered().length) {
|
|
targetPts = tech.buffered().end(0) - this.timestampOffset;
|
|
}
|
|
// Trim to currentTime if it's ahead of buffered or buffered doesn't exist
|
|
targetPts = Math.max(targetPts, tech.currentTime() - this.timestampOffset);
|
|
|
|
// PTS values are represented in milliseconds
|
|
targetPts *= 1e3;
|
|
targetPts += this.basePtsOffset_;
|
|
|
|
// skip tags with a presentation time less than the seek target
|
|
for (i = 0; i < tags.length; i++) {
|
|
if (tags[i].pts >= targetPts) {
|
|
filteredTags.push(tags[i]);
|
|
}
|
|
}
|
|
|
|
if (filteredTags.length === 0) {
|
|
return;
|
|
}
|
|
|
|
// concatenate the bytes into a single segment
|
|
for (i = 0; i < filteredTags.length; i++) {
|
|
segmentByteLength += filteredTags[i].bytes.byteLength;
|
|
}
|
|
segment = new Uint8Array(segmentByteLength);
|
|
for (i = 0, j = 0; i < filteredTags.length; i++) {
|
|
segment.set(filteredTags[i].bytes, j);
|
|
j += filteredTags[i].bytes.byteLength;
|
|
}
|
|
|
|
return segment;
|
|
}
|
|
|
|
/**
|
|
* Assemble the FLV tags in decoder order.
|
|
*
|
|
* @private
|
|
* @param {Object} segmentData object of segment data
|
|
*/
|
|
}, {
|
|
key: 'getOrderedTags_',
|
|
value: function getOrderedTags_(segmentData) {
|
|
var videoTags = segmentData.tags.videoTags;
|
|
var audioTags = segmentData.tags.audioTags;
|
|
var tag = undefined;
|
|
var tags = [];
|
|
|
|
while (videoTags.length || audioTags.length) {
|
|
if (!videoTags.length) {
|
|
// only audio tags remain
|
|
tag = audioTags.shift();
|
|
} else if (!audioTags.length) {
|
|
// only video tags remain
|
|
tag = videoTags.shift();
|
|
} else if (audioTags[0].dts < videoTags[0].dts) {
|
|
// audio should be decoded next
|
|
tag = audioTags.shift();
|
|
} else {
|
|
// video should be decoded next
|
|
tag = videoTags.shift();
|
|
}
|
|
|
|
tags.push(tag.finalize());
|
|
}
|
|
|
|
return tags;
|
|
}
|
|
}]);
|
|
|
|
return FlashSourceBuffer;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = FlashSourceBuffer;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./add-text-track-data":25,"./create-text-tracks-if-necessary":27,"./flash-constants":28,"./remove-cues-from-track":32,"mux.js":43}],31:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file html-media-source.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _virtualSourceBuffer = require('./virtual-source-buffer');
|
|
|
|
var _virtualSourceBuffer2 = _interopRequireDefault(_virtualSourceBuffer);
|
|
|
|
var _codecUtils = require('./codec-utils');
|
|
|
|
/**
|
|
* Replace the old apple-style `avc1.<dd>.<dd>` codec string with the standard
|
|
* `avc1.<hhhhhh>`
|
|
*
|
|
* @param {Array} codecs an array of codec strings to fix
|
|
* @return {Array} the translated codec array
|
|
* @private
|
|
*/
|
|
var translateLegacyCodecs = function translateLegacyCodecs(codecs) {
|
|
return codecs.map(function (codec) {
|
|
return codec.replace(/avc1\.(\d+)\.(\d+)/i, function (orig, profile, avcLevel) {
|
|
var profileHex = ('00' + Number(profile).toString(16)).slice(-2);
|
|
var avcLevelHex = ('00' + Number(avcLevel).toString(16)).slice(-2);
|
|
|
|
return 'avc1.' + profileHex + '00' + avcLevelHex;
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Our MediaSource implementation in HTML, mimics native
|
|
* MediaSource where/if possible.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource
|
|
* @class HtmlMediaSource
|
|
* @extends videojs.EventTarget
|
|
*/
|
|
|
|
var HtmlMediaSource = (function (_videojs$EventTarget) {
|
|
_inherits(HtmlMediaSource, _videojs$EventTarget);
|
|
|
|
function HtmlMediaSource() {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, HtmlMediaSource);
|
|
|
|
_get(Object.getPrototypeOf(HtmlMediaSource.prototype), 'constructor', this).call(this);
|
|
var property = undefined;
|
|
|
|
this.nativeMediaSource_ = new window.MediaSource();
|
|
// delegate to the native MediaSource's methods by default
|
|
for (property in this.nativeMediaSource_) {
|
|
if (!(property in HtmlMediaSource.prototype) && typeof this.nativeMediaSource_[property] === 'function') {
|
|
this[property] = this.nativeMediaSource_[property].bind(this.nativeMediaSource_);
|
|
}
|
|
}
|
|
|
|
// emulate `duration` and `seekable` until seeking can be
|
|
// handled uniformly for live streams
|
|
// see https://github.com/w3c/media-source/issues/5
|
|
this.duration_ = NaN;
|
|
Object.defineProperty(this, 'duration', {
|
|
get: function get() {
|
|
if (this.duration_ === Infinity) {
|
|
return this.duration_;
|
|
}
|
|
return this.nativeMediaSource_.duration;
|
|
},
|
|
set: function set(duration) {
|
|
this.duration_ = duration;
|
|
if (duration !== Infinity) {
|
|
this.nativeMediaSource_.duration = duration;
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
Object.defineProperty(this, 'seekable', {
|
|
get: function get() {
|
|
if (this.duration_ === Infinity) {
|
|
return _videoJs2['default'].createTimeRanges([[0, this.nativeMediaSource_.duration]]);
|
|
}
|
|
return this.nativeMediaSource_.seekable;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(this, 'readyState', {
|
|
get: function get() {
|
|
return this.nativeMediaSource_.readyState;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(this, 'activeSourceBuffers', {
|
|
get: function get() {
|
|
return this.activeSourceBuffers_;
|
|
}
|
|
});
|
|
|
|
// the list of virtual and native SourceBuffers created by this
|
|
// MediaSource
|
|
this.sourceBuffers = [];
|
|
|
|
this.activeSourceBuffers_ = [];
|
|
|
|
/**
|
|
* update the list of active source buffers based upon various
|
|
* imformation from HLS and video.js
|
|
*
|
|
* @private
|
|
*/
|
|
this.updateActiveSourceBuffers_ = function () {
|
|
// Retain the reference but empty the array
|
|
_this.activeSourceBuffers_.length = 0;
|
|
|
|
// By default, the audio in the combined virtual source buffer is enabled
|
|
// and the audio-only source buffer (if it exists) is disabled.
|
|
var combined = false;
|
|
var audioOnly = true;
|
|
|
|
// TODO: maybe we can store the sourcebuffers on the track objects?
|
|
// safari may do something like this
|
|
for (var i = 0; i < _this.player_.audioTracks().length; i++) {
|
|
var track = _this.player_.audioTracks()[i];
|
|
|
|
if (track.enabled && track.kind !== 'main') {
|
|
// The enabled track is an alternate audio track so disable the audio in
|
|
// the combined source buffer and enable the audio-only source buffer.
|
|
combined = true;
|
|
audioOnly = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Since we currently support a max of two source buffers, add all of the source
|
|
// buffers (in order).
|
|
_this.sourceBuffers.forEach(function (sourceBuffer) {
|
|
/* eslinst-disable */
|
|
// TODO once codecs are required, we can switch to using the codecs to determine
|
|
// what stream is the video stream, rather than relying on videoTracks
|
|
/* eslinst-enable */
|
|
|
|
if (sourceBuffer.videoCodec_ && sourceBuffer.audioCodec_) {
|
|
// combined
|
|
sourceBuffer.audioDisabled_ = combined;
|
|
} else if (sourceBuffer.videoCodec_ && !sourceBuffer.audioCodec_) {
|
|
// If the "combined" source buffer is video only, then we do not want
|
|
// disable the audio-only source buffer (this is mostly for demuxed
|
|
// audio and video hls)
|
|
sourceBuffer.audioDisabled_ = true;
|
|
audioOnly = false;
|
|
} else if (!sourceBuffer.videoCodec_ && sourceBuffer.audioCodec_) {
|
|
// audio only
|
|
sourceBuffer.audioDisabled_ = audioOnly;
|
|
if (audioOnly) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
_this.activeSourceBuffers_.push(sourceBuffer);
|
|
});
|
|
};
|
|
|
|
// Re-emit MediaSource events on the polyfill
|
|
['sourceopen', 'sourceclose', 'sourceended'].forEach(function (eventName) {
|
|
this.nativeMediaSource_.addEventListener(eventName, this.trigger.bind(this));
|
|
}, this);
|
|
|
|
// capture the associated player when the MediaSource is
|
|
// successfully attached
|
|
this.on('sourceopen', function (event) {
|
|
// Get the player this MediaSource is attached to
|
|
var video = document.querySelector('[src="' + _this.url_ + '"]');
|
|
|
|
if (!video) {
|
|
return;
|
|
}
|
|
|
|
_this.player_ = (0, _videoJs2['default'])(video.parentNode);
|
|
|
|
if (_this.player_.audioTracks && _this.player_.audioTracks()) {
|
|
_this.player_.audioTracks().on('change', _this.updateActiveSourceBuffers_);
|
|
_this.player_.audioTracks().on('addtrack', _this.updateActiveSourceBuffers_);
|
|
_this.player_.audioTracks().on('removetrack', _this.updateActiveSourceBuffers_);
|
|
}
|
|
});
|
|
|
|
// explicitly terminate any WebWorkers that were created
|
|
// by SourceHandlers
|
|
this.on('sourceclose', function (event) {
|
|
this.sourceBuffers.forEach(function (sourceBuffer) {
|
|
if (sourceBuffer.transmuxer_) {
|
|
sourceBuffer.transmuxer_.terminate();
|
|
}
|
|
});
|
|
this.sourceBuffers.length = 0;
|
|
if (!this.player_) {
|
|
return;
|
|
}
|
|
|
|
if (this.player_.audioTracks && this.player_.audioTracks()) {
|
|
this.player_.audioTracks().off('change', this.updateActiveSourceBuffers_);
|
|
this.player_.audioTracks().off('addtrack', this.updateActiveSourceBuffers_);
|
|
this.player_.audioTracks().off('removetrack', this.updateActiveSourceBuffers_);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Add a range that that can now be seeked to.
|
|
*
|
|
* @param {Double} start where to start the addition
|
|
* @param {Double} end where to end the addition
|
|
* @private
|
|
*/
|
|
|
|
_createClass(HtmlMediaSource, [{
|
|
key: 'addSeekableRange_',
|
|
value: function addSeekableRange_(start, end) {
|
|
var error = undefined;
|
|
|
|
if (this.duration !== Infinity) {
|
|
error = new Error('MediaSource.addSeekableRange() can only be invoked ' + 'when the duration is Infinity');
|
|
error.name = 'InvalidStateError';
|
|
error.code = 11;
|
|
throw error;
|
|
}
|
|
|
|
if (end > this.nativeMediaSource_.duration || isNaN(this.nativeMediaSource_.duration)) {
|
|
this.nativeMediaSource_.duration = end;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a source buffer to the media source.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource/addSourceBuffer
|
|
* @param {String} type the content-type of the content
|
|
* @return {Object} the created source buffer
|
|
*/
|
|
}, {
|
|
key: 'addSourceBuffer',
|
|
value: function addSourceBuffer(type) {
|
|
var buffer = undefined;
|
|
var parsedType = (0, _codecUtils.parseContentType)(type);
|
|
|
|
// Create a VirtualSourceBuffer to transmux MPEG-2 transport
|
|
// stream segments into fragmented MP4s
|
|
if (parsedType.type === 'video/mp2t') {
|
|
var codecs = [];
|
|
|
|
if (parsedType.parameters && parsedType.parameters.codecs) {
|
|
codecs = parsedType.parameters.codecs.split(',');
|
|
codecs = translateLegacyCodecs(codecs);
|
|
codecs = codecs.filter(function (codec) {
|
|
return (0, _codecUtils.isAudioCodec)(codec) || (0, _codecUtils.isVideoCodec)(codec);
|
|
});
|
|
}
|
|
|
|
if (codecs.length === 0) {
|
|
codecs = ['avc1.4d400d', 'mp4a.40.2'];
|
|
}
|
|
|
|
buffer = new _virtualSourceBuffer2['default'](this, codecs);
|
|
|
|
if (this.sourceBuffers.length !== 0) {
|
|
// If another VirtualSourceBuffer already exists, then we are creating a
|
|
// SourceBuffer for an alternate audio track and therefore we know that
|
|
// the source has both an audio and video track.
|
|
// That means we should trigger the manual creation of the real
|
|
// SourceBuffers instead of waiting for the transmuxer to return data
|
|
this.sourceBuffers[0].createRealSourceBuffers_();
|
|
buffer.createRealSourceBuffers_();
|
|
|
|
// Automatically disable the audio on the first source buffer if
|
|
// a second source buffer is ever created
|
|
this.sourceBuffers[0].audioDisabled_ = true;
|
|
}
|
|
} else {
|
|
// delegate to the native implementation
|
|
buffer = this.nativeMediaSource_.addSourceBuffer(type);
|
|
}
|
|
|
|
this.sourceBuffers.push(buffer);
|
|
return buffer;
|
|
}
|
|
}]);
|
|
|
|
return HtmlMediaSource;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = HtmlMediaSource;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./codec-utils":26,"./virtual-source-buffer":35}],32:[function(require,module,exports){
|
|
/**
|
|
* @file remove-cues-from-track.js
|
|
*/
|
|
|
|
/**
|
|
* Remove cues from a track on video.js.
|
|
*
|
|
* @param {Double} start start of where we should remove the cue
|
|
* @param {Double} end end of where the we should remove the cue
|
|
* @param {Object} track the text track to remove the cues from
|
|
* @private
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var removeCuesFromTrack = function removeCuesFromTrack(start, end, track) {
|
|
var i = undefined;
|
|
var cue = undefined;
|
|
|
|
if (!track) {
|
|
return;
|
|
}
|
|
|
|
i = track.cues.length;
|
|
|
|
while (i--) {
|
|
cue = track.cues[i];
|
|
|
|
// Remove any overlapping cue
|
|
if (cue.startTime <= end && cue.endTime >= start) {
|
|
track.removeCue(cue);
|
|
}
|
|
}
|
|
};
|
|
|
|
exports["default"] = removeCuesFromTrack;
|
|
module.exports = exports["default"];
|
|
},{}],33:[function(require,module,exports){
|
|
/**
|
|
* @file transmuxer-worker.js
|
|
*/
|
|
|
|
/**
|
|
* videojs-contrib-media-sources
|
|
*
|
|
* Copyright (c) 2015 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* Handles communication between the browser-world and the mux.js
|
|
* transmuxer running inside of a WebWorker by exposing a simple
|
|
* message-based interface to a Transmuxer object.
|
|
*/
|
|
'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 _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 _muxJs = require('mux.js');
|
|
|
|
var _muxJs2 = _interopRequireDefault(_muxJs);
|
|
|
|
/**
|
|
* Re-emits tranmsuxer events by converting them into messages to the
|
|
* world outside the worker.
|
|
*
|
|
* @param {Object} transmuxer the transmuxer to wire events on
|
|
* @private
|
|
*/
|
|
var wireTransmuxerEvents = function wireTransmuxerEvents(transmuxer) {
|
|
transmuxer.on('data', function (segment) {
|
|
// transfer ownership of the underlying ArrayBuffer
|
|
// instead of doing a copy to save memory
|
|
// ArrayBuffers are transferable but generic TypedArrays are not
|
|
// @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers#Passing_data_by_transferring_ownership_(transferable_objects)
|
|
var typedArray = segment.data;
|
|
|
|
segment.data = typedArray.buffer;
|
|
postMessage({
|
|
action: 'data',
|
|
segment: segment,
|
|
byteOffset: typedArray.byteOffset,
|
|
byteLength: typedArray.byteLength
|
|
}, [segment.data]);
|
|
});
|
|
|
|
if (transmuxer.captionStream) {
|
|
transmuxer.captionStream.on('data', function (caption) {
|
|
postMessage({
|
|
action: 'caption',
|
|
data: caption
|
|
});
|
|
});
|
|
}
|
|
|
|
transmuxer.on('done', function (data) {
|
|
postMessage({ action: 'done' });
|
|
});
|
|
};
|
|
|
|
/**
|
|
* All incoming messages route through this hash. If no function exists
|
|
* to handle an incoming message, then we ignore the message.
|
|
*
|
|
* @class MessageHandlers
|
|
* @param {Object} options the options to initialize with
|
|
*/
|
|
|
|
var MessageHandlers = (function () {
|
|
function MessageHandlers(options) {
|
|
_classCallCheck(this, MessageHandlers);
|
|
|
|
this.options = options || {};
|
|
this.init();
|
|
}
|
|
|
|
/**
|
|
* Our web wroker interface so that things can talk to mux.js
|
|
* that will be running in a web worker. the scope is passed to this by
|
|
* webworkify.
|
|
*
|
|
* @param {Object} self the scope for the web worker
|
|
*/
|
|
|
|
/**
|
|
* initialize our web worker and wire all the events.
|
|
*/
|
|
|
|
_createClass(MessageHandlers, [{
|
|
key: 'init',
|
|
value: function init() {
|
|
if (this.transmuxer) {
|
|
this.transmuxer.dispose();
|
|
}
|
|
this.transmuxer = new _muxJs2['default'].mp4.Transmuxer(this.options);
|
|
wireTransmuxerEvents(this.transmuxer);
|
|
}
|
|
|
|
/**
|
|
* Adds data (a ts segment) to the start of the transmuxer pipeline for
|
|
* processing.
|
|
*
|
|
* @param {ArrayBuffer} data data to push into the muxer
|
|
*/
|
|
}, {
|
|
key: 'push',
|
|
value: function push(data) {
|
|
// Cast array buffer to correct type for transmuxer
|
|
var segment = new Uint8Array(data.data, data.byteOffset, data.byteLength);
|
|
|
|
this.transmuxer.push(segment);
|
|
}
|
|
|
|
/**
|
|
* Recreate the transmuxer so that the next segment added via `push`
|
|
* start with a fresh transmuxer.
|
|
*/
|
|
}, {
|
|
key: 'reset',
|
|
value: function reset() {
|
|
this.init();
|
|
}
|
|
|
|
/**
|
|
* Set the value that will be used as the `baseMediaDecodeTime` time for the
|
|
* next segment pushed in. Subsequent segments will have their `baseMediaDecodeTime`
|
|
* set relative to the first based on the PTS values.
|
|
*
|
|
* @param {Object} data used to set the timestamp offset in the muxer
|
|
*/
|
|
}, {
|
|
key: 'setTimestampOffset',
|
|
value: function setTimestampOffset(data) {
|
|
var timestampOffset = data.timestampOffset || 0;
|
|
|
|
this.transmuxer.setBaseMediaDecodeTime(Math.round(timestampOffset * 90000));
|
|
}
|
|
|
|
/**
|
|
* Forces the pipeline to finish processing the last segment and emit it's
|
|
* results.
|
|
*
|
|
* @param {Object} data event data, not really used
|
|
*/
|
|
}, {
|
|
key: 'flush',
|
|
value: function flush(data) {
|
|
this.transmuxer.flush();
|
|
}
|
|
}]);
|
|
|
|
return MessageHandlers;
|
|
})();
|
|
|
|
var Worker = function Worker(self) {
|
|
self.onmessage = function (event) {
|
|
if (event.data.action === 'init' && event.data.options) {
|
|
this.messageHandlers = new MessageHandlers(event.data.options);
|
|
return;
|
|
}
|
|
|
|
if (!this.messageHandlers) {
|
|
this.messageHandlers = new MessageHandlers();
|
|
}
|
|
|
|
if (event.data && event.data.action && event.data.action !== 'init') {
|
|
if (this.messageHandlers[event.data.action]) {
|
|
this.messageHandlers[event.data.action](event.data);
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
exports['default'] = function (self) {
|
|
return new Worker(self);
|
|
};
|
|
|
|
module.exports = exports['default'];
|
|
},{"mux.js":43}],34:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file videojs-contrib-media-sources.js
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _flashMediaSource = require('./flash-media-source');
|
|
|
|
var _flashMediaSource2 = _interopRequireDefault(_flashMediaSource);
|
|
|
|
var _htmlMediaSource = require('./html-media-source');
|
|
|
|
var _htmlMediaSource2 = _interopRequireDefault(_htmlMediaSource);
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var urlCount = 0;
|
|
|
|
// ------------
|
|
// Media Source
|
|
// ------------
|
|
|
|
var defaults = {
|
|
// how to determine the MediaSource implementation to use. There
|
|
// are three available modes:
|
|
// - auto: use native MediaSources where available and Flash
|
|
// everywhere else
|
|
// - html5: always use native MediaSources
|
|
// - flash: always use the Flash MediaSource polyfill
|
|
mode: 'auto'
|
|
};
|
|
|
|
// store references to the media sources so they can be connected
|
|
// to a video element (a swf object)
|
|
// TODO: can we store this somewhere local to this module?
|
|
_videoJs2['default'].mediaSources = {};
|
|
|
|
/**
|
|
* Provide a method for a swf object to notify JS that a
|
|
* media source is now open.
|
|
*
|
|
* @param {String} msObjectURL string referencing the MSE Object URL
|
|
* @param {String} swfId the swf id
|
|
*/
|
|
var open = function open(msObjectURL, swfId) {
|
|
var mediaSource = _videoJs2['default'].mediaSources[msObjectURL];
|
|
|
|
if (mediaSource) {
|
|
mediaSource.trigger({ type: 'sourceopen', swfId: swfId });
|
|
} else {
|
|
throw new Error('Media Source not found (Video.js)');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Check to see if the native MediaSource object exists and supports
|
|
* an MP4 container with both H.264 video and AAC-LC audio.
|
|
*
|
|
* @return {Boolean} if native media sources are supported
|
|
*/
|
|
var supportsNativeMediaSources = function supportsNativeMediaSources() {
|
|
return !!window.MediaSource && !!window.MediaSource.isTypeSupported && window.MediaSource.isTypeSupported('video/mp4;codecs="avc1.4d400d,mp4a.40.2"');
|
|
};
|
|
|
|
/**
|
|
* An emulation of the MediaSource API so that we can support
|
|
* native and non-native functionality such as flash and
|
|
* video/mp2t videos. returns an instance of HtmlMediaSource or
|
|
* FlashMediaSource depending on what is supported and what options
|
|
* are passed in.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource/MediaSource
|
|
* @param {Object} options options to use during setup.
|
|
*/
|
|
var MediaSource = function MediaSource(options) {
|
|
var settings = _videoJs2['default'].mergeOptions(defaults, options);
|
|
|
|
this.MediaSource = {
|
|
open: open,
|
|
supportsNativeMediaSources: supportsNativeMediaSources
|
|
};
|
|
|
|
// determine whether HTML MediaSources should be used
|
|
if (settings.mode === 'html5' || settings.mode === 'auto' && supportsNativeMediaSources()) {
|
|
return new _htmlMediaSource2['default']();
|
|
}
|
|
|
|
// otherwise, emulate them through the SWF
|
|
return new _flashMediaSource2['default']();
|
|
};
|
|
|
|
exports.MediaSource = MediaSource;
|
|
MediaSource.open = open;
|
|
MediaSource.supportsNativeMediaSources = supportsNativeMediaSources;
|
|
|
|
/**
|
|
* A wrapper around the native URL for our MSE object
|
|
* implementation, this object is exposed under videojs.URL
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/URL/URL
|
|
*/
|
|
var URL = {
|
|
/**
|
|
* A wrapper around the native createObjectURL for our objects.
|
|
* This function maps a native or emulated mediaSource to a blob
|
|
* url so that it can be loaded into video.js
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
|
|
* @param {MediaSource} object the object to create a blob url to
|
|
*/
|
|
createObjectURL: function createObjectURL(object) {
|
|
var objectUrlPrefix = 'blob:vjs-media-source/';
|
|
var url = undefined;
|
|
|
|
// use the native MediaSource to generate an object URL
|
|
if (object instanceof _htmlMediaSource2['default']) {
|
|
url = window.URL.createObjectURL(object.nativeMediaSource_);
|
|
object.url_ = url;
|
|
return url;
|
|
}
|
|
// if the object isn't an emulated MediaSource, delegate to the
|
|
// native implementation
|
|
if (!(object instanceof _flashMediaSource2['default'])) {
|
|
url = window.URL.createObjectURL(object);
|
|
object.url_ = url;
|
|
return url;
|
|
}
|
|
|
|
// build a URL that can be used to map back to the emulated
|
|
// MediaSource
|
|
url = objectUrlPrefix + urlCount;
|
|
|
|
urlCount++;
|
|
|
|
// setup the mapping back to object
|
|
_videoJs2['default'].mediaSources[url] = object;
|
|
|
|
return url;
|
|
}
|
|
};
|
|
|
|
exports.URL = URL;
|
|
_videoJs2['default'].MediaSource = MediaSource;
|
|
_videoJs2['default'].URL = URL;
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./flash-media-source":29,"./html-media-source":31}],35:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file virtual-source-buffer.js
|
|
*/
|
|
'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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _createTextTracksIfNecessary = require('./create-text-tracks-if-necessary');
|
|
|
|
var _createTextTracksIfNecessary2 = _interopRequireDefault(_createTextTracksIfNecessary);
|
|
|
|
var _removeCuesFromTrack = require('./remove-cues-from-track');
|
|
|
|
var _removeCuesFromTrack2 = _interopRequireDefault(_removeCuesFromTrack);
|
|
|
|
var _addTextTrackData = require('./add-text-track-data');
|
|
|
|
var _addTextTrackData2 = _interopRequireDefault(_addTextTrackData);
|
|
|
|
var _webworkify = require('webworkify');
|
|
|
|
var _webworkify2 = _interopRequireDefault(_webworkify);
|
|
|
|
var _transmuxerWorker = require('./transmuxer-worker');
|
|
|
|
var _transmuxerWorker2 = _interopRequireDefault(_transmuxerWorker);
|
|
|
|
var _codecUtils = require('./codec-utils');
|
|
|
|
/**
|
|
* VirtualSourceBuffers exist so that we can transmux non native formats
|
|
* into a native format, but keep the same api as a native source buffer.
|
|
* It creates a transmuxer, that works in its own thread (a web worker) and
|
|
* that transmuxer muxes the data into a native format. VirtualSourceBuffer will
|
|
* then send all of that data to the naive sourcebuffer so that it is
|
|
* indestinguishable from a natively supported format.
|
|
*
|
|
* @param {HtmlMediaSource} mediaSource the parent mediaSource
|
|
* @param {Array} codecs array of codecs that we will be dealing with
|
|
* @class VirtualSourceBuffer
|
|
* @extends video.js.EventTarget
|
|
*/
|
|
|
|
var VirtualSourceBuffer = (function (_videojs$EventTarget) {
|
|
_inherits(VirtualSourceBuffer, _videojs$EventTarget);
|
|
|
|
function VirtualSourceBuffer(mediaSource, codecs) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, VirtualSourceBuffer);
|
|
|
|
_get(Object.getPrototypeOf(VirtualSourceBuffer.prototype), 'constructor', this).call(this, _videoJs2['default'].EventTarget);
|
|
this.timestampOffset_ = 0;
|
|
this.pendingBuffers_ = [];
|
|
this.bufferUpdating_ = false;
|
|
this.mediaSource_ = mediaSource;
|
|
this.codecs_ = codecs;
|
|
this.audioCodec_ = null;
|
|
this.videoCodec_ = null;
|
|
this.audioDisabled_ = false;
|
|
|
|
var options = {
|
|
remux: false
|
|
};
|
|
|
|
this.codecs_.forEach(function (codec) {
|
|
if ((0, _codecUtils.isAudioCodec)(codec)) {
|
|
_this.audioCodec_ = codec;
|
|
} else if ((0, _codecUtils.isVideoCodec)(codec)) {
|
|
_this.videoCodec_ = codec;
|
|
}
|
|
});
|
|
|
|
// append muxed segments to their respective native buffers as
|
|
// soon as they are available
|
|
this.transmuxer_ = (0, _webworkify2['default'])(_transmuxerWorker2['default']);
|
|
this.transmuxer_.postMessage({ action: 'init', options: options });
|
|
|
|
this.transmuxer_.onmessage = function (event) {
|
|
if (event.data.action === 'data') {
|
|
return _this.data_(event);
|
|
}
|
|
|
|
if (event.data.action === 'done') {
|
|
return _this.done_(event);
|
|
}
|
|
};
|
|
|
|
// this timestampOffset is a property with the side-effect of resetting
|
|
// baseMediaDecodeTime in the transmuxer on the setter
|
|
Object.defineProperty(this, 'timestampOffset', {
|
|
get: function get() {
|
|
return this.timestampOffset_;
|
|
},
|
|
set: function set(val) {
|
|
if (typeof val === 'number' && val >= 0) {
|
|
this.timestampOffset_ = val;
|
|
|
|
// We have to tell the transmuxer to set the baseMediaDecodeTime to
|
|
// the desired timestampOffset for the next segment
|
|
this.transmuxer_.postMessage({
|
|
action: 'setTimestampOffset',
|
|
timestampOffset: val
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// setting the append window affects both source buffers
|
|
Object.defineProperty(this, 'appendWindowStart', {
|
|
get: function get() {
|
|
return (this.videoBuffer_ || this.audioBuffer_).appendWindowStart;
|
|
},
|
|
set: function set(start) {
|
|
if (this.videoBuffer_) {
|
|
this.videoBuffer_.appendWindowStart = start;
|
|
}
|
|
if (this.audioBuffer_) {
|
|
this.audioBuffer_.appendWindowStart = start;
|
|
}
|
|
}
|
|
});
|
|
|
|
// this buffer is "updating" if either of its native buffers are
|
|
Object.defineProperty(this, 'updating', {
|
|
get: function get() {
|
|
return !!(this.bufferUpdating_ || !this.audioDisabled_ && this.audioBuffer_ && this.audioBuffer_.updating || this.videoBuffer_ && this.videoBuffer_.updating);
|
|
}
|
|
});
|
|
|
|
// the buffered property is the intersection of the buffered
|
|
// ranges of the native source buffers
|
|
Object.defineProperty(this, 'buffered', {
|
|
get: function get() {
|
|
var start = null;
|
|
var end = null;
|
|
var arity = 0;
|
|
var extents = [];
|
|
var ranges = [];
|
|
|
|
if (!this.videoBuffer_ && (this.audioDisabled_ || !this.audioBuffer_)) {
|
|
return _videoJs2['default'].createTimeRange();
|
|
}
|
|
|
|
// Handle the case where we only have one buffer
|
|
if (!this.videoBuffer_) {
|
|
return this.audioBuffer_.buffered;
|
|
} else if (this.audioDisabled_ || !this.audioBuffer_) {
|
|
return this.videoBuffer_.buffered;
|
|
}
|
|
|
|
// Handle the case where there is no buffer data
|
|
if ((!this.videoBuffer_ || this.videoBuffer_.buffered.length === 0) && (!this.audioBuffer_ || this.audioBuffer_.buffered.length === 0)) {
|
|
return _videoJs2['default'].createTimeRange();
|
|
}
|
|
|
|
// Handle the case where we have both buffers and create an
|
|
// intersection of the two
|
|
var videoBuffered = this.videoBuffer_.buffered;
|
|
var audioBuffered = this.audioBuffer_.buffered;
|
|
var count = videoBuffered.length;
|
|
|
|
// A) Gather up all start and end times
|
|
while (count--) {
|
|
extents.push({ time: videoBuffered.start(count), type: 'start' });
|
|
extents.push({ time: videoBuffered.end(count), type: 'end' });
|
|
}
|
|
count = audioBuffered.length;
|
|
while (count--) {
|
|
extents.push({ time: audioBuffered.start(count), type: 'start' });
|
|
extents.push({ time: audioBuffered.end(count), type: 'end' });
|
|
}
|
|
// B) Sort them by time
|
|
extents.sort(function (a, b) {
|
|
return a.time - b.time;
|
|
});
|
|
|
|
// C) Go along one by one incrementing arity for start and decrementing
|
|
// arity for ends
|
|
for (count = 0; count < extents.length; count++) {
|
|
if (extents[count].type === 'start') {
|
|
arity++;
|
|
|
|
// D) If arity is ever incremented to 2 we are entering an
|
|
// overlapping range
|
|
if (arity === 2) {
|
|
start = extents[count].time;
|
|
}
|
|
} else if (extents[count].type === 'end') {
|
|
arity--;
|
|
|
|
// E) If arity is ever decremented to 1 we leaving an
|
|
// overlapping range
|
|
if (arity === 1) {
|
|
end = extents[count].time;
|
|
}
|
|
}
|
|
|
|
// F) Record overlapping ranges
|
|
if (start !== null && end !== null) {
|
|
ranges.push([start, end]);
|
|
start = null;
|
|
end = null;
|
|
}
|
|
}
|
|
|
|
return _videoJs2['default'].createTimeRanges(ranges);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* When we get a data event from the transmuxer
|
|
* we call this function and handle the data that
|
|
* was sent to us
|
|
*
|
|
* @private
|
|
* @param {Event} event the data event from the transmuxer
|
|
*/
|
|
|
|
_createClass(VirtualSourceBuffer, [{
|
|
key: 'data_',
|
|
value: function data_(event) {
|
|
var segment = event.data.segment;
|
|
|
|
// Cast ArrayBuffer to TypedArray
|
|
segment.data = new Uint8Array(segment.data, event.data.byteOffset, event.data.byteLength);
|
|
|
|
(0, _createTextTracksIfNecessary2['default'])(this, this.mediaSource_, segment);
|
|
|
|
// Add the segments to the pendingBuffers array
|
|
this.pendingBuffers_.push(segment);
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* When we get a done event from the transmuxer
|
|
* we call this function and we process all
|
|
* of the pending data that we have been saving in the
|
|
* data_ function
|
|
*
|
|
* @private
|
|
* @param {Event} event the done event from the transmuxer
|
|
*/
|
|
}, {
|
|
key: 'done_',
|
|
value: function done_(event) {
|
|
// All buffers should have been flushed from the muxer
|
|
// start processing anything we have received
|
|
this.processPendingSegments_();
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Create our internal native audio/video source buffers and add
|
|
* event handlers to them with the following conditions:
|
|
* 1. they do not already exist on the mediaSource
|
|
* 2. this VSB has a codec for them
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'createRealSourceBuffers_',
|
|
value: function createRealSourceBuffers_() {
|
|
var _this2 = this;
|
|
|
|
var types = ['audio', 'video'];
|
|
|
|
types.forEach(function (type) {
|
|
// Don't create a SourceBuffer of this type if we don't have a
|
|
// codec for it
|
|
if (!_this2[type + 'Codec_']) {
|
|
return;
|
|
}
|
|
|
|
// Do nothing if a SourceBuffer of this type already exists
|
|
if (_this2[type + 'Buffer_']) {
|
|
return;
|
|
}
|
|
|
|
var buffer = null;
|
|
|
|
// If the mediasource already has a SourceBuffer for the codec
|
|
// use that
|
|
if (_this2.mediaSource_[type + 'Buffer_']) {
|
|
buffer = _this2.mediaSource_[type + 'Buffer_'];
|
|
} else {
|
|
buffer = _this2.mediaSource_.nativeMediaSource_.addSourceBuffer(type + '/mp4;codecs="' + _this2[type + 'Codec_'] + '"');
|
|
_this2.mediaSource_[type + 'Buffer_'] = buffer;
|
|
}
|
|
|
|
_this2[type + 'Buffer_'] = buffer;
|
|
|
|
// Wire up the events to the SourceBuffer
|
|
['update', 'updatestart', 'updateend'].forEach(function (event) {
|
|
buffer.addEventListener(event, function () {
|
|
// if audio is disabled
|
|
if (type === 'audio' && _this2.audioDisabled_) {
|
|
return;
|
|
}
|
|
|
|
var shouldTrigger = types.every(function (t) {
|
|
// skip checking audio's updating status if audio
|
|
// is not enabled
|
|
if (t === 'audio' && _this2.audioDisabled_) {
|
|
return true;
|
|
}
|
|
// if the other type if updating we don't trigger
|
|
if (type !== t && _this2[t + 'Buffer_'] && _this2[t + 'Buffer_'].updating) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (shouldTrigger) {
|
|
return _this2.trigger(event);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Emulate the native mediasource function, but our function will
|
|
* send all of the proposed segments to the transmuxer so that we
|
|
* can transmux them before we append them to our internal
|
|
* native source buffers in the correct format.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/appendBuffer
|
|
* @param {Uint8Array} segment the segment to append to the buffer
|
|
*/
|
|
}, {
|
|
key: 'appendBuffer',
|
|
value: function appendBuffer(segment) {
|
|
// Start the internal "updating" state
|
|
this.bufferUpdating_ = true;
|
|
|
|
this.transmuxer_.postMessage({
|
|
action: 'push',
|
|
// Send the typed-array of data as an ArrayBuffer so that
|
|
// it can be sent as a "Transferable" and avoid the costly
|
|
// memory copy
|
|
data: segment.buffer,
|
|
|
|
// To recreate the original typed-array, we need information
|
|
// about what portion of the ArrayBuffer it was a view into
|
|
byteOffset: segment.byteOffset,
|
|
byteLength: segment.byteLength
|
|
}, [segment.buffer]);
|
|
this.transmuxer_.postMessage({ action: 'flush' });
|
|
}
|
|
|
|
/**
|
|
* Emulate the native mediasource function and remove parts
|
|
* of the buffer from any of our internal buffers that exist
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/remove
|
|
* @param {Double} start position to start the remove at
|
|
* @param {Double} end position to end the remove at
|
|
*/
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(start, end) {
|
|
if (this.videoBuffer_) {
|
|
this.videoBuffer_.remove(start, end);
|
|
}
|
|
if (!this.audioDisabled_ && this.audioBuffer_) {
|
|
this.audioBuffer_.remove(start, end);
|
|
}
|
|
|
|
// Remove Metadata Cues (id3)
|
|
(0, _removeCuesFromTrack2['default'])(start, end, this.metadataTrack_);
|
|
|
|
// Remove Any Captions
|
|
(0, _removeCuesFromTrack2['default'])(start, end, this.inbandTextTrack_);
|
|
}
|
|
|
|
/**
|
|
* Process any segments that the muxer has output
|
|
* Concatenate segments together based on type and append them into
|
|
* their respective sourceBuffers
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'processPendingSegments_',
|
|
value: function processPendingSegments_() {
|
|
var sortedSegments = {
|
|
video: {
|
|
segments: [],
|
|
bytes: 0
|
|
},
|
|
audio: {
|
|
segments: [],
|
|
bytes: 0
|
|
},
|
|
captions: [],
|
|
metadata: []
|
|
};
|
|
|
|
// Sort segments into separate video/audio arrays and
|
|
// keep track of their total byte lengths
|
|
sortedSegments = this.pendingBuffers_.reduce(function (segmentObj, segment) {
|
|
var type = segment.type;
|
|
var data = segment.data;
|
|
|
|
segmentObj[type].segments.push(data);
|
|
segmentObj[type].bytes += data.byteLength;
|
|
|
|
// Gather any captions into a single array
|
|
if (segment.captions) {
|
|
segmentObj.captions = segmentObj.captions.concat(segment.captions);
|
|
}
|
|
|
|
if (segment.info) {
|
|
segmentObj[type].info = segment.info;
|
|
}
|
|
|
|
// Gather any metadata into a single array
|
|
if (segment.metadata) {
|
|
segmentObj.metadata = segmentObj.metadata.concat(segment.metadata);
|
|
}
|
|
|
|
return segmentObj;
|
|
}, sortedSegments);
|
|
|
|
// Create the real source buffers if they don't exist by now since we
|
|
// finally are sure what tracks are contained in the source
|
|
if (!this.videoBuffer_ && !this.audioBuffer_) {
|
|
// Remove any codecs that may have been specified by default but
|
|
// are no longer applicable now
|
|
if (sortedSegments.video.bytes === 0) {
|
|
this.videoCodec_ = null;
|
|
}
|
|
if (sortedSegments.audio.bytes === 0) {
|
|
this.audioCodec_ = null;
|
|
}
|
|
|
|
this.createRealSourceBuffers_();
|
|
}
|
|
|
|
if (sortedSegments.audio.info) {
|
|
this.mediaSource_.trigger({ type: 'audioinfo', info: sortedSegments.audio.info });
|
|
}
|
|
if (sortedSegments.video.info) {
|
|
this.mediaSource_.trigger({ type: 'videoinfo', info: sortedSegments.video.info });
|
|
}
|
|
|
|
// Merge multiple video and audio segments into one and append
|
|
if (this.videoBuffer_) {
|
|
this.concatAndAppendSegments_(sortedSegments.video, this.videoBuffer_);
|
|
// TODO: are video tracks the only ones with text tracks?
|
|
(0, _addTextTrackData2['default'])(this, sortedSegments.captions, sortedSegments.metadata);
|
|
}
|
|
if (!this.audioDisabled_ && this.audioBuffer_) {
|
|
this.concatAndAppendSegments_(sortedSegments.audio, this.audioBuffer_);
|
|
}
|
|
|
|
this.pendingBuffers_.length = 0;
|
|
|
|
// We are no longer in the internal "updating" state
|
|
this.bufferUpdating_ = false;
|
|
}
|
|
|
|
/**
|
|
* Combine all segments into a single Uint8Array and then append them
|
|
* to the destination buffer
|
|
*
|
|
* @param {Object} segmentObj
|
|
* @param {SourceBuffer} destinationBuffer native source buffer to append data to
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'concatAndAppendSegments_',
|
|
value: function concatAndAppendSegments_(segmentObj, destinationBuffer) {
|
|
var offset = 0;
|
|
var tempBuffer = undefined;
|
|
|
|
if (segmentObj.bytes) {
|
|
tempBuffer = new Uint8Array(segmentObj.bytes);
|
|
|
|
// Combine the individual segments into one large typed-array
|
|
segmentObj.segments.forEach(function (segment) {
|
|
tempBuffer.set(segment, offset);
|
|
offset += segment.byteLength;
|
|
});
|
|
|
|
destinationBuffer.appendBuffer(tempBuffer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Emulate the native mediasource function. abort any soureBuffer
|
|
* actions and throw out any un-appended data.
|
|
*
|
|
* @link https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer/abort
|
|
*/
|
|
}, {
|
|
key: 'abort',
|
|
value: function abort() {
|
|
if (this.videoBuffer_) {
|
|
this.videoBuffer_.abort();
|
|
}
|
|
if (this.audioBuffer_) {
|
|
this.audioBuffer_.abort();
|
|
}
|
|
if (this.transmuxer_) {
|
|
this.transmuxer_.postMessage({ action: 'reset' });
|
|
}
|
|
this.pendingBuffers_.length = 0;
|
|
this.bufferUpdating_ = false;
|
|
}
|
|
}]);
|
|
|
|
return VirtualSourceBuffer;
|
|
})(_videoJs2['default'].EventTarget);
|
|
|
|
exports['default'] = VirtualSourceBuffer;
|
|
module.exports = exports['default'];
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./add-text-track-data":25,"./codec-utils":26,"./create-text-tracks-if-necessary":27,"./remove-cues-from-track":32,"./transmuxer-worker":33,"webworkify":56}],36:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2016 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* A stream-based aac to mp4 converter. This utility can be used to
|
|
* deliver mp4s to a SourceBuffer on platforms that support native
|
|
* Media Source Extensions.
|
|
*/
|
|
'use strict';
|
|
var Stream = require('../utils/stream.js');
|
|
|
|
// Constants
|
|
var AacStream;
|
|
|
|
/**
|
|
* Splits an incoming stream of binary data into ADTS and ID3 Frames.
|
|
*/
|
|
|
|
AacStream = function() {
|
|
var
|
|
everything = new Uint8Array(),
|
|
receivedTimeStamp = false,
|
|
timeStamp = 0;
|
|
|
|
AacStream.prototype.init.call(this);
|
|
|
|
this.setTimestamp = function (timestamp) {
|
|
timeStamp = timestamp;
|
|
};
|
|
|
|
this.parseId3TagSize = function(header, byteIndex) {
|
|
var
|
|
returnSize = (header[byteIndex + 6] << 21) |
|
|
(header[byteIndex + 7] << 14) |
|
|
(header[byteIndex + 8] << 7) |
|
|
(header[byteIndex + 9]),
|
|
flags = header[byteIndex + 5],
|
|
footerPresent = (flags & 16) >> 4;
|
|
|
|
if (footerPresent) {
|
|
return returnSize + 20;
|
|
}
|
|
return returnSize + 10;
|
|
};
|
|
|
|
this.parseAdtsSize = function(header, byteIndex) {
|
|
var
|
|
lowThree = (header[byteIndex + 5] & 0xE0) >> 5,
|
|
middle = header[byteIndex + 4] << 3,
|
|
highTwo = header[byteIndex + 3] & 0x3 << 11;
|
|
|
|
return (highTwo | middle) | lowThree;
|
|
};
|
|
|
|
this.push = function(bytes) {
|
|
var
|
|
frameSize = 0,
|
|
byteIndex = 0,
|
|
bytesLeft,
|
|
chunk,
|
|
packet,
|
|
tempLength;
|
|
|
|
// If there are bytes remaining from the last segment, prepend them to the
|
|
// bytes that were pushed in
|
|
if (everything.length) {
|
|
tempLength = everything.length;
|
|
everything = new Uint8Array(bytes.byteLength + tempLength);
|
|
everything.set(everything.subarray(0, tempLength));
|
|
everything.set(bytes, tempLength);
|
|
} else {
|
|
everything = bytes;
|
|
}
|
|
|
|
while (everything.length - byteIndex >= 3) {
|
|
if ((everything[byteIndex] === 'I'.charCodeAt(0)) &&
|
|
(everything[byteIndex + 1] === 'D'.charCodeAt(0)) &&
|
|
(everything[byteIndex + 2] === '3'.charCodeAt(0))) {
|
|
|
|
// Exit early because we don't have enough to parse
|
|
// the ID3 tag header
|
|
if (everything.length - byteIndex < 10) {
|
|
break;
|
|
}
|
|
|
|
// check framesize
|
|
frameSize = this.parseId3TagSize(everything, byteIndex);
|
|
|
|
// Exit early if we don't have enough in the buffer
|
|
// to emit a full packet
|
|
if (frameSize > everything.length) {
|
|
break;
|
|
}
|
|
chunk = {
|
|
type: 'timed-metadata',
|
|
data: everything.subarray(byteIndex, byteIndex + frameSize)
|
|
};
|
|
this.trigger('data', chunk);
|
|
byteIndex += frameSize;
|
|
continue;
|
|
} else if ((everything[byteIndex] & 0xff === 0xff) &&
|
|
((everything[byteIndex + 1] & 0xf0) === 0xf0)) {
|
|
|
|
// Exit early because we don't have enough to parse
|
|
// the ADTS frame header
|
|
if (everything.length - byteIndex < 7) {
|
|
break;
|
|
}
|
|
|
|
frameSize = this.parseAdtsSize(everything, byteIndex);
|
|
|
|
// Exit early if we don't have enough in the buffer
|
|
// to emit a full packet
|
|
if (frameSize > everything.length) {
|
|
break;
|
|
}
|
|
|
|
packet = {
|
|
type: 'audio',
|
|
data: everything.subarray(byteIndex, byteIndex + frameSize),
|
|
pts: timeStamp,
|
|
dts: timeStamp,
|
|
};
|
|
this.trigger('data', packet);
|
|
byteIndex += frameSize;
|
|
continue;
|
|
}
|
|
byteIndex++;
|
|
}
|
|
bytesLeft = everything.length - byteIndex;
|
|
|
|
if (bytesLeft > 0) {
|
|
everything = everything.subarray(byteIndex);
|
|
} else {
|
|
everything = new Uint8Array();
|
|
}
|
|
};
|
|
};
|
|
|
|
AacStream.prototype = new Stream();
|
|
|
|
|
|
|
|
module.exports = AacStream;
|
|
|
|
},{"../utils/stream.js":55}],37:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Stream = require('../utils/stream.js');
|
|
|
|
var AdtsStream;
|
|
|
|
var
|
|
ADTS_SAMPLING_FREQUENCIES = [
|
|
96000,
|
|
88200,
|
|
64000,
|
|
48000,
|
|
44100,
|
|
32000,
|
|
24000,
|
|
22050,
|
|
16000,
|
|
12000,
|
|
11025,
|
|
8000,
|
|
7350
|
|
];
|
|
|
|
/*
|
|
* Accepts a ElementaryStream and emits data events with parsed
|
|
* AAC Audio Frames of the individual packets. Input audio in ADTS
|
|
* format is unpacked and re-emitted as AAC frames.
|
|
*
|
|
* @see http://wiki.multimedia.cx/index.php?title=ADTS
|
|
* @see http://wiki.multimedia.cx/?title=Understanding_AAC
|
|
*/
|
|
AdtsStream = function() {
|
|
var self, buffer;
|
|
|
|
AdtsStream.prototype.init.call(this);
|
|
|
|
self = this;
|
|
|
|
this.push = function(packet) {
|
|
var
|
|
i = 0,
|
|
frameNum = 0,
|
|
frameLength,
|
|
protectionSkipBytes,
|
|
frameEnd,
|
|
oldBuffer,
|
|
numFrames,
|
|
sampleCount,
|
|
adtsFrameDuration;
|
|
|
|
if (packet.type !== 'audio') {
|
|
// ignore non-audio data
|
|
return;
|
|
}
|
|
|
|
// Prepend any data in the buffer to the input data so that we can parse
|
|
// aac frames the cross a PES packet boundary
|
|
if (buffer) {
|
|
oldBuffer = buffer;
|
|
buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);
|
|
buffer.set(oldBuffer);
|
|
buffer.set(packet.data, oldBuffer.byteLength);
|
|
} else {
|
|
buffer = packet.data;
|
|
}
|
|
|
|
// unpack any ADTS frames which have been fully received
|
|
// for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS
|
|
while (i + 5 < buffer.length) {
|
|
|
|
// Loook for the start of an ADTS header..
|
|
if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {
|
|
// If a valid header was not found, jump one forward and attempt to
|
|
// find a valid ADTS header starting at the next byte
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
// The protection skip bit tells us if we have 2 bytes of CRC data at the
|
|
// end of the ADTS header
|
|
protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2;
|
|
|
|
// Frame length is a 13 bit integer starting 16 bits from the
|
|
// end of the sync sequence
|
|
frameLength = ((buffer[i + 3] & 0x03) << 11) |
|
|
(buffer[i + 4] << 3) |
|
|
((buffer[i + 5] & 0xe0) >> 5);
|
|
|
|
sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;
|
|
adtsFrameDuration = (sampleCount * 90000) /
|
|
ADTS_SAMPLING_FREQUENCIES[(buffer[i + 2] & 0x3c) >>> 2];
|
|
|
|
frameEnd = i + frameLength;
|
|
|
|
// If we don't have enough data to actually finish this ADTS frame, return
|
|
// and wait for more data
|
|
if (buffer.byteLength < frameEnd) {
|
|
return;
|
|
}
|
|
|
|
// Otherwise, deliver the complete AAC frame
|
|
this.trigger('data', {
|
|
pts: packet.pts + (frameNum * adtsFrameDuration),
|
|
dts: packet.dts + (frameNum * adtsFrameDuration),
|
|
sampleCount: sampleCount,
|
|
audioobjecttype: ((buffer[i + 2] >>> 6) & 0x03) + 1,
|
|
channelcount: ((buffer[i + 2] & 1) << 2) |
|
|
((buffer[i + 3] & 0xc0) >>> 6),
|
|
samplerate: ADTS_SAMPLING_FREQUENCIES[(buffer[i + 2] & 0x3c) >>> 2],
|
|
samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,
|
|
// assume ISO/IEC 14496-12 AudioSampleEntry default of 16
|
|
samplesize: 16,
|
|
data: buffer.subarray(i + 7 + protectionSkipBytes, frameEnd)
|
|
});
|
|
|
|
// If the buffer is empty, clear it and return
|
|
if (buffer.byteLength === frameEnd) {
|
|
buffer = undefined;
|
|
return;
|
|
}
|
|
|
|
frameNum++;
|
|
|
|
// Remove the finished frame from the buffer and start the process again
|
|
buffer = buffer.subarray(frameEnd);
|
|
}
|
|
};
|
|
this.flush = function() {
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
|
|
AdtsStream.prototype = new Stream();
|
|
|
|
module.exports = AdtsStream;
|
|
|
|
},{"../utils/stream.js":55}],38:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Stream = require('../utils/stream.js');
|
|
var ExpGolomb = require('../utils/exp-golomb.js');
|
|
|
|
var H264Stream, NalByteStream;
|
|
|
|
/**
|
|
* Accepts a NAL unit byte stream and unpacks the embedded NAL units.
|
|
*/
|
|
NalByteStream = function() {
|
|
var
|
|
syncPoint = 0,
|
|
i,
|
|
buffer;
|
|
NalByteStream.prototype.init.call(this);
|
|
|
|
this.push = function(data) {
|
|
var swapBuffer;
|
|
|
|
if (!buffer) {
|
|
buffer = data.data;
|
|
} else {
|
|
swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);
|
|
swapBuffer.set(buffer);
|
|
swapBuffer.set(data.data, buffer.byteLength);
|
|
buffer = swapBuffer;
|
|
}
|
|
|
|
// Rec. ITU-T H.264, Annex B
|
|
// scan for NAL unit boundaries
|
|
|
|
// a match looks like this:
|
|
// 0 0 1 .. NAL .. 0 0 1
|
|
// ^ sync point ^ i
|
|
// or this:
|
|
// 0 0 1 .. NAL .. 0 0 0
|
|
// ^ sync point ^ i
|
|
|
|
// advance the sync point to a NAL start, if necessary
|
|
for (; syncPoint < buffer.byteLength - 3; syncPoint++) {
|
|
if (buffer[syncPoint + 2] === 1) {
|
|
// the sync point is properly aligned
|
|
i = syncPoint + 5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (i < buffer.byteLength) {
|
|
// look at the current byte to determine if we've hit the end of
|
|
// a NAL unit boundary
|
|
switch (buffer[i]) {
|
|
case 0:
|
|
// skip past non-sync sequences
|
|
if (buffer[i - 1] !== 0) {
|
|
i += 2;
|
|
break;
|
|
} else if (buffer[i - 2] !== 0) {
|
|
i++;
|
|
break;
|
|
}
|
|
|
|
// deliver the NAL unit if it isn't empty
|
|
if (syncPoint + 3 !== i - 2) {
|
|
this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
|
|
}
|
|
|
|
// drop trailing zeroes
|
|
do {
|
|
i++;
|
|
} while (buffer[i] !== 1 && i < buffer.length);
|
|
syncPoint = i - 2;
|
|
i += 3;
|
|
break;
|
|
case 1:
|
|
// skip past non-sync sequences
|
|
if (buffer[i - 1] !== 0 ||
|
|
buffer[i - 2] !== 0) {
|
|
i += 3;
|
|
break;
|
|
}
|
|
|
|
// deliver the NAL unit
|
|
this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));
|
|
syncPoint = i - 2;
|
|
i += 3;
|
|
break;
|
|
default:
|
|
// the current byte isn't a one or zero, so it cannot be part
|
|
// of a sync sequence
|
|
i += 3;
|
|
break;
|
|
}
|
|
}
|
|
// filter out the NAL units that were delivered
|
|
buffer = buffer.subarray(syncPoint);
|
|
i -= syncPoint;
|
|
syncPoint = 0;
|
|
};
|
|
|
|
this.flush = function() {
|
|
// deliver the last buffered NAL unit
|
|
if (buffer && buffer.byteLength > 3) {
|
|
this.trigger('data', buffer.subarray(syncPoint + 3));
|
|
}
|
|
// reset the stream state
|
|
buffer = null;
|
|
syncPoint = 0;
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
NalByteStream.prototype = new Stream();
|
|
|
|
/**
|
|
* Accepts input from a ElementaryStream and produces H.264 NAL unit data
|
|
* events.
|
|
*/
|
|
H264Stream = function() {
|
|
var
|
|
nalByteStream = new NalByteStream(),
|
|
self,
|
|
trackId,
|
|
currentPts,
|
|
currentDts,
|
|
|
|
discardEmulationPreventionBytes,
|
|
readSequenceParameterSet,
|
|
skipScalingList;
|
|
|
|
H264Stream.prototype.init.call(this);
|
|
self = this;
|
|
|
|
this.push = function(packet) {
|
|
if (packet.type !== 'video') {
|
|
return;
|
|
}
|
|
trackId = packet.trackId;
|
|
currentPts = packet.pts;
|
|
currentDts = packet.dts;
|
|
|
|
nalByteStream.push(packet);
|
|
};
|
|
|
|
nalByteStream.on('data', function(data) {
|
|
var
|
|
event = {
|
|
trackId: trackId,
|
|
pts: currentPts,
|
|
dts: currentDts,
|
|
data: data
|
|
};
|
|
|
|
switch (data[0] & 0x1f) {
|
|
case 0x05:
|
|
event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';
|
|
break;
|
|
case 0x06:
|
|
event.nalUnitType = 'sei_rbsp';
|
|
event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
|
|
break;
|
|
case 0x07:
|
|
event.nalUnitType = 'seq_parameter_set_rbsp';
|
|
event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));
|
|
event.config = readSequenceParameterSet(event.escapedRBSP);
|
|
break;
|
|
case 0x08:
|
|
event.nalUnitType = 'pic_parameter_set_rbsp';
|
|
break;
|
|
case 0x09:
|
|
event.nalUnitType = 'access_unit_delimiter_rbsp';
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
self.trigger('data', event);
|
|
});
|
|
nalByteStream.on('done', function() {
|
|
self.trigger('done');
|
|
});
|
|
|
|
this.flush = function() {
|
|
nalByteStream.flush();
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
* @param expGolombDecoder {object} an ExpGolomb pointed to the
|
|
* start of a scaling list
|
|
* @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
|
|
*/
|
|
skipScalingList = function(count, expGolombDecoder) {
|
|
var
|
|
lastScale = 8,
|
|
nextScale = 8,
|
|
j,
|
|
deltaScale;
|
|
|
|
for (j = 0; j < count; j++) {
|
|
if (nextScale !== 0) {
|
|
deltaScale = expGolombDecoder.readExpGolomb();
|
|
nextScale = (lastScale + deltaScale + 256) % 256;
|
|
}
|
|
|
|
lastScale = (nextScale === 0) ? lastScale : nextScale;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Expunge any "Emulation Prevention" bytes from a "Raw Byte
|
|
* Sequence Payload"
|
|
* @param data {Uint8Array} the bytes of a RBSP from a NAL
|
|
* unit
|
|
* @return {Uint8Array} the RBSP without any Emulation
|
|
* Prevention Bytes
|
|
*/
|
|
discardEmulationPreventionBytes = function(data) {
|
|
var
|
|
length = data.byteLength,
|
|
emulationPreventionBytesPositions = [],
|
|
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) {
|
|
emulationPreventionBytesPositions.push(i + 2);
|
|
i += 2;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
|
|
// If no Emulation Prevention Bytes were found just return the original
|
|
// array
|
|
if (emulationPreventionBytesPositions.length === 0) {
|
|
return data;
|
|
}
|
|
|
|
// Create a new array to hold the NAL unit data
|
|
newLength = length - emulationPreventionBytesPositions.length;
|
|
newData = new Uint8Array(newLength);
|
|
var sourceIndex = 0;
|
|
|
|
for (i = 0; i < newLength; sourceIndex++, i++) {
|
|
if (sourceIndex === emulationPreventionBytesPositions[0]) {
|
|
// Skip this byte
|
|
sourceIndex++;
|
|
// Remove this position index
|
|
emulationPreventionBytesPositions.shift();
|
|
}
|
|
newData[i] = data[sourceIndex];
|
|
}
|
|
|
|
return newData;
|
|
};
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
readSequenceParameterSet = function(data) {
|
|
var
|
|
frameCropLeftOffset = 0,
|
|
frameCropRightOffset = 0,
|
|
frameCropTopOffset = 0,
|
|
frameCropBottomOffset = 0,
|
|
sarScale = 1,
|
|
expGolombDecoder, profileIdc, levelIdc, profileCompatibility,
|
|
chromaFormatIdc, picOrderCntType,
|
|
numRefFramesInPicOrderCntCycle, picWidthInMbsMinus1,
|
|
picHeightInMapUnitsMinus1,
|
|
frameMbsOnlyFlag,
|
|
scalingListCount,
|
|
sarRatio,
|
|
aspectRatioIdc,
|
|
i;
|
|
|
|
expGolombDecoder = new ExpGolomb(data);
|
|
profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc
|
|
profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag
|
|
levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)
|
|
expGolombDecoder.skipUnsignedExpGolomb(); // 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 ||
|
|
profileIdc === 138 ||
|
|
profileIdc === 139 ||
|
|
profileIdc === 134) {
|
|
chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();
|
|
if (chromaFormatIdc === 3) {
|
|
expGolombDecoder.skipBits(1); // separate_colour_plane_flag
|
|
}
|
|
expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8
|
|
expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8
|
|
expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
|
|
if (expGolombDecoder.readBoolean()) { // seq_scaling_matrix_present_flag
|
|
scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
|
|
for (i = 0; i < scalingListCount; i++) {
|
|
if (expGolombDecoder.readBoolean()) { // seq_scaling_list_present_flag[ i ]
|
|
if (i < 6) {
|
|
skipScalingList(16, expGolombDecoder);
|
|
} else {
|
|
skipScalingList(64, expGolombDecoder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4
|
|
picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();
|
|
|
|
if (picOrderCntType === 0) {
|
|
expGolombDecoder.readUnsignedExpGolomb(); //log2_max_pic_order_cnt_lsb_minus4
|
|
} else if (picOrderCntType === 1) {
|
|
expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag
|
|
expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic
|
|
expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field
|
|
numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();
|
|
for(i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
|
|
expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]
|
|
}
|
|
}
|
|
|
|
expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames
|
|
expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
|
|
|
|
picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
|
|
picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();
|
|
|
|
frameMbsOnlyFlag = expGolombDecoder.readBits(1);
|
|
if (frameMbsOnlyFlag === 0) {
|
|
expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag
|
|
}
|
|
|
|
expGolombDecoder.skipBits(1); // direct_8x8_inference_flag
|
|
if (expGolombDecoder.readBoolean()) { // frame_cropping_flag
|
|
frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();
|
|
frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();
|
|
frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();
|
|
frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();
|
|
}
|
|
if (expGolombDecoder.readBoolean()) {
|
|
// vui_parameters_present_flag
|
|
if (expGolombDecoder.readBoolean()) {
|
|
// aspect_ratio_info_present_flag
|
|
aspectRatioIdc = expGolombDecoder.readUnsignedByte();
|
|
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 = [expGolombDecoder.readUnsignedByte() << 8 |
|
|
expGolombDecoder.readUnsignedByte(),
|
|
expGolombDecoder.readUnsignedByte() << 8 |
|
|
expGolombDecoder.readUnsignedByte() ];
|
|
break;
|
|
}
|
|
}
|
|
if (sarRatio) {
|
|
sarScale = sarRatio[0] / sarRatio[1];
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
profileIdc: profileIdc,
|
|
levelIdc: levelIdc,
|
|
profileCompatibility: profileCompatibility,
|
|
width: Math.ceil((((picWidthInMbsMinus1 + 1) * 16) - frameCropLeftOffset * 2 - frameCropRightOffset * 2) * sarScale),
|
|
height: ((2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16) - (frameCropTopOffset * 2) - (frameCropBottomOffset * 2)
|
|
};
|
|
};
|
|
|
|
};
|
|
H264Stream.prototype = new Stream();
|
|
|
|
module.exports = {
|
|
H264Stream: H264Stream,
|
|
NalByteStream: NalByteStream,
|
|
};
|
|
|
|
},{"../utils/exp-golomb.js":54,"../utils/stream.js":55}],39:[function(require,module,exports){
|
|
module.exports = {
|
|
adts: require('./adts'),
|
|
h264: require('./h264'),
|
|
};
|
|
|
|
},{"./adts":37,"./h264":38}],40:[function(require,module,exports){
|
|
/**
|
|
* An object that stores the bytes of an FLV tag and methods for
|
|
* querying and manipulating that data.
|
|
* @see http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf
|
|
*/
|
|
'use strict';
|
|
|
|
var FlvTag;
|
|
|
|
// (type:uint, extraData:Boolean = false) extends ByteArray
|
|
FlvTag = function(type, extraData) {
|
|
var
|
|
// Counter if this is a metadata tag, nal start marker if this is a video
|
|
// tag. unused if this is an audio tag
|
|
adHoc = 0, // :uint
|
|
|
|
// The default size is 16kb but this is not enough to hold iframe
|
|
// data and the resizing algorithm costs a bit so we create a larger
|
|
// starting buffer for video tags
|
|
bufferStartSize = 16384,
|
|
|
|
// checks whether the FLV tag has enough capacity to accept the proposed
|
|
// write and re-allocates the internal buffers if necessary
|
|
prepareWrite = function(flv, count) {
|
|
var
|
|
bytes,
|
|
minLength = flv.position + count;
|
|
if (minLength < flv.bytes.byteLength) {
|
|
// there's enough capacity so do nothing
|
|
return;
|
|
}
|
|
|
|
// allocate a new buffer and copy over the data that will not be modified
|
|
bytes = new Uint8Array(minLength * 2);
|
|
bytes.set(flv.bytes.subarray(0, flv.position), 0);
|
|
flv.bytes = bytes;
|
|
flv.view = new DataView(flv.bytes.buffer);
|
|
},
|
|
|
|
// commonly used metadata properties
|
|
widthBytes = FlvTag.widthBytes || new Uint8Array('width'.length),
|
|
heightBytes = FlvTag.heightBytes || new Uint8Array('height'.length),
|
|
videocodecidBytes = FlvTag.videocodecidBytes || new Uint8Array('videocodecid'.length),
|
|
i;
|
|
|
|
if (!FlvTag.widthBytes) {
|
|
// calculating the bytes of common metadata names ahead of time makes the
|
|
// corresponding writes faster because we don't have to loop over the
|
|
// characters
|
|
// re-test with test/perf.html if you're planning on changing this
|
|
for (i = 0; i < 'width'.length; i++) {
|
|
widthBytes[i] = 'width'.charCodeAt(i);
|
|
}
|
|
for (i = 0; i < 'height'.length; i++) {
|
|
heightBytes[i] = 'height'.charCodeAt(i);
|
|
}
|
|
for (i = 0; i < 'videocodecid'.length; i++) {
|
|
videocodecidBytes[i] = 'videocodecid'.charCodeAt(i);
|
|
}
|
|
|
|
FlvTag.widthBytes = widthBytes;
|
|
FlvTag.heightBytes = heightBytes;
|
|
FlvTag.videocodecidBytes = videocodecidBytes;
|
|
}
|
|
|
|
this.keyFrame = false; // :Boolean
|
|
|
|
switch(type) {
|
|
case FlvTag.VIDEO_TAG:
|
|
this.length = 16;
|
|
// Start the buffer at 256k
|
|
bufferStartSize *= 6;
|
|
break;
|
|
case FlvTag.AUDIO_TAG:
|
|
this.length = 13;
|
|
this.keyFrame = true;
|
|
break;
|
|
case FlvTag.METADATA_TAG:
|
|
this.length = 29;
|
|
this.keyFrame = true;
|
|
break;
|
|
default:
|
|
throw("Error Unknown TagType");
|
|
}
|
|
|
|
this.bytes = new Uint8Array(bufferStartSize);
|
|
this.view = new DataView(this.bytes.buffer);
|
|
this.bytes[0] = type;
|
|
this.position = this.length;
|
|
this.keyFrame = extraData; // Defaults to false
|
|
|
|
// presentation timestamp
|
|
this.pts = 0;
|
|
// decoder timestamp
|
|
this.dts = 0;
|
|
|
|
// ByteArray#writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0)
|
|
this.writeBytes = function(bytes, offset, length) {
|
|
var
|
|
start = offset || 0,
|
|
end;
|
|
length = length || bytes.byteLength;
|
|
end = start + length;
|
|
|
|
prepareWrite(this, length);
|
|
this.bytes.set(bytes.subarray(start, end), this.position);
|
|
|
|
this.position += length;
|
|
this.length = Math.max(this.length, this.position);
|
|
};
|
|
|
|
// ByteArray#writeByte(value:int):void
|
|
this.writeByte = function(byte) {
|
|
prepareWrite(this, 1);
|
|
this.bytes[this.position] = byte;
|
|
this.position++;
|
|
this.length = Math.max(this.length, this.position);
|
|
};
|
|
|
|
// ByteArray#writeShort(value:int):void
|
|
this.writeShort = function(short) {
|
|
prepareWrite(this, 2);
|
|
this.view.setUint16(this.position, short);
|
|
this.position += 2;
|
|
this.length = Math.max(this.length, this.position);
|
|
};
|
|
|
|
// Negative index into array
|
|
// (pos:uint):int
|
|
this.negIndex = function(pos) {
|
|
return this.bytes[this.length - pos];
|
|
};
|
|
|
|
// The functions below ONLY work when this[0] == VIDEO_TAG.
|
|
// We are not going to check for that because we dont want the overhead
|
|
// (nal:ByteArray = null):int
|
|
this.nalUnitSize = function() {
|
|
if (adHoc === 0) {
|
|
return 0;
|
|
}
|
|
|
|
return this.length - (adHoc + 4);
|
|
};
|
|
|
|
this.startNalUnit = function() {
|
|
// remember position and add 4 bytes
|
|
if (adHoc > 0) {
|
|
throw new Error("Attempted to create new NAL wihout closing the old one");
|
|
}
|
|
|
|
// reserve 4 bytes for nal unit size
|
|
adHoc = this.length;
|
|
this.length += 4;
|
|
this.position = this.length;
|
|
};
|
|
|
|
// (nal:ByteArray = null):void
|
|
this.endNalUnit = function(nalContainer) {
|
|
var
|
|
nalStart, // :uint
|
|
nalLength; // :uint
|
|
|
|
// Rewind to the marker and write the size
|
|
if (this.length === adHoc + 4) {
|
|
// we started a nal unit, but didnt write one, so roll back the 4 byte size value
|
|
this.length -= 4;
|
|
} else if (adHoc > 0) {
|
|
nalStart = adHoc + 4;
|
|
nalLength = this.length - nalStart;
|
|
|
|
this.position = adHoc;
|
|
this.view.setUint32(this.position, nalLength);
|
|
this.position = this.length;
|
|
|
|
if (nalContainer) {
|
|
// Add the tag to the NAL unit
|
|
nalContainer.push(this.bytes.subarray(nalStart, nalStart + nalLength));
|
|
}
|
|
}
|
|
|
|
adHoc = 0;
|
|
};
|
|
|
|
/**
|
|
* Write out a 64-bit floating point valued metadata property. This method is
|
|
* called frequently during a typical parse and needs to be fast.
|
|
*/
|
|
// (key:String, val:Number):void
|
|
this.writeMetaDataDouble = function(key, val) {
|
|
var i;
|
|
prepareWrite(this, 2 + key.length + 9);
|
|
|
|
// write size of property name
|
|
this.view.setUint16(this.position, key.length);
|
|
this.position += 2;
|
|
|
|
// this next part looks terrible but it improves parser throughput by
|
|
// 10kB/s in my testing
|
|
|
|
// write property name
|
|
if (key === 'width') {
|
|
this.bytes.set(widthBytes, this.position);
|
|
this.position += 5;
|
|
} else if (key === 'height') {
|
|
this.bytes.set(heightBytes, this.position);
|
|
this.position += 6;
|
|
} else if (key === 'videocodecid') {
|
|
this.bytes.set(videocodecidBytes, this.position);
|
|
this.position += 12;
|
|
} else {
|
|
for (i = 0; i < key.length; i++) {
|
|
this.bytes[this.position] = key.charCodeAt(i);
|
|
this.position++;
|
|
}
|
|
}
|
|
|
|
// skip null byte
|
|
this.position++;
|
|
|
|
// write property value
|
|
this.view.setFloat64(this.position, val);
|
|
this.position += 8;
|
|
|
|
// update flv tag length
|
|
this.length = Math.max(this.length, this.position);
|
|
++adHoc;
|
|
};
|
|
|
|
// (key:String, val:Boolean):void
|
|
this.writeMetaDataBoolean = function(key, val) {
|
|
var i;
|
|
prepareWrite(this, 2);
|
|
this.view.setUint16(this.position, key.length);
|
|
this.position += 2;
|
|
for (i = 0; i < key.length; i++) {
|
|
// if key.charCodeAt(i) >= 255, handle error
|
|
prepareWrite(this, 1);
|
|
this.bytes[this.position] = key.charCodeAt(i);
|
|
this.position++;
|
|
}
|
|
prepareWrite(this, 2);
|
|
this.view.setUint8(this.position, 0x01);
|
|
this.position++;
|
|
this.view.setUint8(this.position, val ? 0x01 : 0x00);
|
|
this.position++;
|
|
this.length = Math.max(this.length, this.position);
|
|
++adHoc;
|
|
};
|
|
|
|
// ():ByteArray
|
|
this.finalize = function() {
|
|
var
|
|
dtsDelta, // :int
|
|
len; // :int
|
|
|
|
switch(this.bytes[0]) {
|
|
// Video Data
|
|
case FlvTag.VIDEO_TAG:
|
|
this.bytes[11] = ((this.keyFrame || extraData) ? 0x10 : 0x20 ) | 0x07; // We only support AVC, 1 = key frame (for AVC, a seekable frame), 2 = inter frame (for AVC, a non-seekable frame)
|
|
this.bytes[12] = extraData ? 0x00 : 0x01;
|
|
|
|
dtsDelta = this.pts - this.dts;
|
|
this.bytes[13] = (dtsDelta & 0x00FF0000) >>> 16;
|
|
this.bytes[14] = (dtsDelta & 0x0000FF00) >>> 8;
|
|
this.bytes[15] = (dtsDelta & 0x000000FF) >>> 0;
|
|
break;
|
|
|
|
case FlvTag.AUDIO_TAG:
|
|
this.bytes[11] = 0xAF; // 44 kHz, 16-bit stereo
|
|
this.bytes[12] = extraData ? 0x00 : 0x01;
|
|
break;
|
|
|
|
case FlvTag.METADATA_TAG:
|
|
this.position = 11;
|
|
this.view.setUint8(this.position, 0x02); // String type
|
|
this.position++;
|
|
this.view.setUint16(this.position, 0x0A); // 10 Bytes
|
|
this.position += 2;
|
|
// set "onMetaData"
|
|
this.bytes.set([0x6f, 0x6e, 0x4d, 0x65,
|
|
0x74, 0x61, 0x44, 0x61,
|
|
0x74, 0x61], this.position);
|
|
this.position += 10;
|
|
this.bytes[this.position] = 0x08; // Array type
|
|
this.position++;
|
|
this.view.setUint32(this.position, adHoc);
|
|
this.position = this.length;
|
|
this.bytes.set([0, 0, 9], this.position);
|
|
this.position += 3; // End Data Tag
|
|
this.length = this.position;
|
|
break;
|
|
}
|
|
|
|
len = this.length - 11;
|
|
|
|
// write the DataSize field
|
|
this.bytes[ 1] = (len & 0x00FF0000) >>> 16;
|
|
this.bytes[ 2] = (len & 0x0000FF00) >>> 8;
|
|
this.bytes[ 3] = (len & 0x000000FF) >>> 0;
|
|
// write the Timestamp
|
|
this.bytes[ 4] = (this.dts & 0x00FF0000) >>> 16;
|
|
this.bytes[ 5] = (this.dts & 0x0000FF00) >>> 8;
|
|
this.bytes[ 6] = (this.dts & 0x000000FF) >>> 0;
|
|
this.bytes[ 7] = (this.dts & 0xFF000000) >>> 24;
|
|
// write the StreamID
|
|
this.bytes[ 8] = 0;
|
|
this.bytes[ 9] = 0;
|
|
this.bytes[10] = 0;
|
|
|
|
// Sometimes we're at the end of the view and have one slot to write a
|
|
// uint32, so, prepareWrite of count 4, since, view is uint8
|
|
prepareWrite(this, 4);
|
|
this.view.setUint32(this.length, this.length);
|
|
this.length += 4;
|
|
this.position += 4;
|
|
|
|
// trim down the byte buffer to what is actually being used
|
|
this.bytes = this.bytes.subarray(0, this.length);
|
|
this.frameTime = FlvTag.frameTime(this.bytes);
|
|
// if bytes.bytelength isn't equal to this.length, handle error
|
|
return this;
|
|
};
|
|
};
|
|
|
|
FlvTag.AUDIO_TAG = 0x08; // == 8, :uint
|
|
FlvTag.VIDEO_TAG = 0x09; // == 9, :uint
|
|
FlvTag.METADATA_TAG = 0x12; // == 18, :uint
|
|
|
|
// (tag:ByteArray):Boolean {
|
|
FlvTag.isAudioFrame = function(tag) {
|
|
return FlvTag.AUDIO_TAG === tag[0];
|
|
};
|
|
|
|
// (tag:ByteArray):Boolean {
|
|
FlvTag.isVideoFrame = function(tag) {
|
|
return FlvTag.VIDEO_TAG === tag[0];
|
|
};
|
|
|
|
// (tag:ByteArray):Boolean {
|
|
FlvTag.isMetaData = function(tag) {
|
|
return FlvTag.METADATA_TAG === tag[0];
|
|
};
|
|
|
|
// (tag:ByteArray):Boolean {
|
|
FlvTag.isKeyFrame = function(tag) {
|
|
if (FlvTag.isVideoFrame(tag)) {
|
|
return tag[11] === 0x17;
|
|
}
|
|
|
|
if (FlvTag.isAudioFrame(tag)) {
|
|
return true;
|
|
}
|
|
|
|
if (FlvTag.isMetaData(tag)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
// (tag:ByteArray):uint {
|
|
FlvTag.frameTime = function(tag) {
|
|
var pts = tag[ 4] << 16; // :uint
|
|
pts |= tag[ 5] << 8;
|
|
pts |= tag[ 6] << 0;
|
|
pts |= tag[ 7] << 24;
|
|
return pts;
|
|
};
|
|
|
|
module.exports = FlvTag;
|
|
|
|
},{}],41:[function(require,module,exports){
|
|
module.exports = {
|
|
tag: require('./flv-tag'),
|
|
Transmuxer: require('./transmuxer'),
|
|
tools: require('../tools/flv-inspector'),
|
|
};
|
|
|
|
},{"../tools/flv-inspector":52,"./flv-tag":40,"./transmuxer":42}],42:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Stream = require('../utils/stream.js');
|
|
var FlvTag = require('./flv-tag.js');
|
|
var m2ts = require('../m2ts/m2ts.js');
|
|
var AdtsStream = require('../codecs/adts.js');
|
|
var H264Stream = require('../codecs/h264').H264Stream;
|
|
|
|
var
|
|
MetadataStream,
|
|
Transmuxer,
|
|
VideoSegmentStream,
|
|
AudioSegmentStream,
|
|
CoalesceStream,
|
|
collectTimelineInfo,
|
|
metaDataTag,
|
|
extraDataTag;
|
|
|
|
/**
|
|
* Store information about the start and end of the tracka and the
|
|
* duration for each frame/sample we process in order to calculate
|
|
* the baseMediaDecodeTime
|
|
*/
|
|
collectTimelineInfo = function (track, data) {
|
|
if (typeof data.pts === 'number') {
|
|
if (track.timelineStartInfo.pts === undefined) {
|
|
track.timelineStartInfo.pts = data.pts;
|
|
} else {
|
|
track.timelineStartInfo.pts =
|
|
Math.min(track.timelineStartInfo.pts, data.pts);
|
|
}
|
|
}
|
|
|
|
if (typeof data.dts === 'number') {
|
|
if (track.timelineStartInfo.dts === undefined) {
|
|
track.timelineStartInfo.dts = data.dts;
|
|
} else {
|
|
track.timelineStartInfo.dts =
|
|
Math.min(track.timelineStartInfo.dts, data.dts);
|
|
}
|
|
}
|
|
};
|
|
|
|
metaDataTag = function(track, pts) {
|
|
var
|
|
tag = new FlvTag(FlvTag.METADATA_TAG); // :FlvTag
|
|
|
|
tag.dts = pts;
|
|
tag.pts = pts;
|
|
|
|
tag.writeMetaDataDouble("videocodecid", 7);
|
|
tag.writeMetaDataDouble("width", track.width);
|
|
tag.writeMetaDataDouble("height", track.height);
|
|
|
|
return tag;
|
|
};
|
|
|
|
extraDataTag = function(track, pts) {
|
|
var
|
|
i,
|
|
tag = new FlvTag(FlvTag.VIDEO_TAG, true);
|
|
|
|
tag.dts = pts;
|
|
tag.pts = pts;
|
|
|
|
tag.writeByte(0x01);// version
|
|
tag.writeByte(track.profileIdc);// profile
|
|
tag.writeByte(track.profileCompatibility);// compatibility
|
|
tag.writeByte(track.levelIdc);// level
|
|
tag.writeByte(0xFC | 0x03); // reserved (6 bits), NULA length size - 1 (2 bits)
|
|
tag.writeByte(0xE0 | 0x01 ); // reserved (3 bits), num of SPS (5 bits)
|
|
tag.writeShort( track.sps[0].length ); // data of SPS
|
|
tag.writeBytes( track.sps[0] ); // SPS
|
|
|
|
tag.writeByte(track.pps.length); // num of PPS (will there ever be more that 1 PPS?)
|
|
for (i = 0 ; i < track.pps.length ; ++i) {
|
|
tag.writeShort(track.pps[i].length); // 2 bytes for length of PPS
|
|
tag.writeBytes(track.pps[i]); // data of PPS
|
|
}
|
|
|
|
return tag;
|
|
};
|
|
|
|
/**
|
|
* Constructs a single-track, media segment from AAC data
|
|
* events. The output of this stream can be fed to flash.
|
|
*/
|
|
AudioSegmentStream = function(track) {
|
|
var
|
|
adtsFrames = [],
|
|
adtsFramesLength = 0,
|
|
sequenceNumber = 0,
|
|
earliestAllowedDts = 0,
|
|
oldExtraData;
|
|
|
|
AudioSegmentStream.prototype.init.call(this);
|
|
|
|
this.push = function(data) {
|
|
collectTimelineInfo(track, data);
|
|
|
|
if (track && track.channelcount === undefined) {
|
|
track.audioobjecttype = data.audioobjecttype;
|
|
track.channelcount = data.channelcount;
|
|
track.samplerate = data.samplerate;
|
|
track.samplingfrequencyindex = data.samplingfrequencyindex;
|
|
track.samplesize = data.samplesize;
|
|
track.extraData = (track.audioobjecttype << 11) |
|
|
(track.samplingfrequencyindex << 7) |
|
|
(track.channelcount << 3);
|
|
}
|
|
|
|
data.pts = Math.round(data.pts / 90);
|
|
data.dts = Math.round(data.dts / 90);
|
|
|
|
// buffer audio data until end() is called
|
|
adtsFrames.push(data);
|
|
};
|
|
|
|
this.flush = function() {
|
|
var currentFrame, adtsFrame, deltaDts,lastMetaPts, tags = [];
|
|
// return early if no audio data has been observed
|
|
if (adtsFrames.length === 0) {
|
|
this.trigger('done');
|
|
return;
|
|
}
|
|
|
|
lastMetaPts = -Infinity;
|
|
|
|
while (adtsFrames.length) {
|
|
currentFrame = adtsFrames.shift();
|
|
|
|
// write out metadata tags every 1 second so that the decoder
|
|
// is re-initialized quickly after seeking into a different
|
|
// audio configuration
|
|
if (track.extraData !== oldExtraData || currentFrame.pts - lastMetaPts >= 1000) {
|
|
adtsFrame = new FlvTag(FlvTag.METADATA_TAG);
|
|
adtsFrame.pts = currentFrame.pts;
|
|
adtsFrame.dts = currentFrame.dts;
|
|
|
|
// AAC is always 10
|
|
adtsFrame.writeMetaDataDouble("audiocodecid", 10);
|
|
adtsFrame.writeMetaDataBoolean("stereo", 2 === track.channelcount);
|
|
adtsFrame.writeMetaDataDouble ("audiosamplerate", track.samplerate);
|
|
// Is AAC always 16 bit?
|
|
adtsFrame.writeMetaDataDouble ("audiosamplesize", 16);
|
|
|
|
tags.push(adtsFrame);
|
|
|
|
oldExtraData = track.extraData;
|
|
|
|
adtsFrame = new FlvTag(FlvTag.AUDIO_TAG, true);
|
|
// For audio, DTS is always the same as PTS. We want to set the DTS
|
|
// however so we can compare with video DTS to determine approximate
|
|
// packet order
|
|
adtsFrame.pts = currentFrame.pts;
|
|
adtsFrame.dts = currentFrame.dts;
|
|
|
|
adtsFrame.view.setUint16(adtsFrame.position, track.extraData);
|
|
adtsFrame.position += 2;
|
|
adtsFrame.length = Math.max(adtsFrame.length, adtsFrame.position);
|
|
|
|
tags.push(adtsFrame);
|
|
|
|
lastMetaPts = currentFrame.pts;
|
|
}
|
|
adtsFrame = new FlvTag(FlvTag.AUDIO_TAG);
|
|
adtsFrame.pts = currentFrame.pts;
|
|
adtsFrame.dts = currentFrame.dts;
|
|
|
|
adtsFrame.writeBytes(currentFrame.data);
|
|
|
|
tags.push(adtsFrame);
|
|
}
|
|
|
|
oldExtraData = null;
|
|
this.trigger('data', {track: track, tags: tags});
|
|
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
AudioSegmentStream.prototype = new Stream();
|
|
|
|
/**
|
|
* Store FlvTags for the h264 stream
|
|
* @param track {object} track metadata configuration
|
|
*/
|
|
VideoSegmentStream = function(track) {
|
|
var
|
|
sequenceNumber = 0,
|
|
nalUnits = [],
|
|
nalUnitsLength = 0,
|
|
config,
|
|
h264Frame;
|
|
VideoSegmentStream.prototype.init.call(this);
|
|
|
|
this.finishFrame = function(tags, frame) {
|
|
if (!frame) {
|
|
return;
|
|
}
|
|
// Check if keyframe and the length of tags.
|
|
// This makes sure we write metadata on the first frame of a segment.
|
|
if (config && track && track.newMetadata &&
|
|
(frame.keyFrame || tags.length === 0)) {
|
|
// Push extra data on every IDR frame in case we did a stream change + seek
|
|
tags.push(metaDataTag(config, frame.pts));
|
|
tags.push(extraDataTag(track, frame.pts));
|
|
track.newMetadata = false;
|
|
}
|
|
|
|
frame.endNalUnit();
|
|
tags.push(frame);
|
|
};
|
|
|
|
this.push = function(data) {
|
|
collectTimelineInfo(track, data);
|
|
|
|
data.pts = Math.round(data.pts / 90);
|
|
data.dts = Math.round(data.dts / 90);
|
|
|
|
// buffer video until flush() is called
|
|
nalUnits.push(data);
|
|
};
|
|
|
|
this.flush = function() {
|
|
var
|
|
currentNal,
|
|
tags = [];
|
|
|
|
// Throw away nalUnits at the start of the byte stream until we find
|
|
// the first AUD
|
|
while (nalUnits.length) {
|
|
if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
|
|
break;
|
|
}
|
|
nalUnits.shift();
|
|
}
|
|
|
|
// return early if no video data has been observed
|
|
if (nalUnits.length === 0) {
|
|
this.trigger('done');
|
|
return;
|
|
}
|
|
|
|
while (nalUnits.length) {
|
|
currentNal = nalUnits.shift();
|
|
|
|
// record the track config
|
|
if (currentNal.nalUnitType === 'seq_parameter_set_rbsp') {
|
|
track.newMetadata = true;
|
|
config = currentNal.config;
|
|
track.width = config.width;
|
|
track.height = config.height;
|
|
track.sps = [currentNal.data];
|
|
track.profileIdc = config.profileIdc;
|
|
track.levelIdc = config.levelIdc;
|
|
track.profileCompatibility = config.profileCompatibility;
|
|
h264Frame.endNalUnit();
|
|
} else if (currentNal.nalUnitType === 'pic_parameter_set_rbsp') {
|
|
track.newMetadata = true;
|
|
track.pps = [currentNal.data];
|
|
h264Frame.endNalUnit();
|
|
} else if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
|
|
if (h264Frame) {
|
|
this.finishFrame(tags, h264Frame);
|
|
}
|
|
h264Frame = new FlvTag(FlvTag.VIDEO_TAG);
|
|
h264Frame.pts = currentNal.pts;
|
|
h264Frame.dts = currentNal.dts;
|
|
} else {
|
|
if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
|
|
// the current sample is a key frame
|
|
h264Frame.keyFrame = true;
|
|
}
|
|
h264Frame.endNalUnit();
|
|
}
|
|
h264Frame.startNalUnit();
|
|
h264Frame.writeBytes(currentNal.data);
|
|
}
|
|
if (h264Frame) {
|
|
this.finishFrame(tags, h264Frame);
|
|
}
|
|
|
|
this.trigger('data', {track: track, tags: tags});
|
|
|
|
// Continue with the flush process now
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
|
|
VideoSegmentStream.prototype = new Stream();
|
|
|
|
/**
|
|
* The final stage of the transmuxer that emits the flv tags
|
|
* for audio, video, and metadata. Also tranlates in time and
|
|
* outputs caption data and id3 cues.
|
|
*/
|
|
CoalesceStream = function(options) {
|
|
// Number of Tracks per output segment
|
|
// If greater than 1, we combine multiple
|
|
// tracks into a single segment
|
|
this.numberOfTracks = 0;
|
|
this.metadataStream = options.metadataStream;
|
|
|
|
this.videoTags = [];
|
|
this.audioTags = [];
|
|
this.videoTrack = null;
|
|
this.audioTrack = null;
|
|
this.pendingCaptions = [];
|
|
this.pendingMetadata = [];
|
|
this.pendingTracks = 0;
|
|
|
|
CoalesceStream.prototype.init.call(this);
|
|
|
|
// Take output from multiple
|
|
this.push = function(output) {
|
|
// buffer incoming captions until the associated video segment
|
|
// finishes
|
|
if (output.text) {
|
|
return this.pendingCaptions.push(output);
|
|
}
|
|
// buffer incoming id3 tags until the final flush
|
|
if (output.frames) {
|
|
return this.pendingMetadata.push(output);
|
|
}
|
|
|
|
if (output.track.type === 'video') {
|
|
this.videoTrack = output.track;
|
|
this.videoTags = output.tags;
|
|
this.pendingTracks++;
|
|
}
|
|
if (output.track.type === 'audio') {
|
|
this.audioTrack = output.track;
|
|
this.audioTags = output.tags;
|
|
this.pendingTracks++;
|
|
}
|
|
};
|
|
};
|
|
|
|
CoalesceStream.prototype = new Stream();
|
|
CoalesceStream.prototype.flush = function() {
|
|
var
|
|
id3,
|
|
caption,
|
|
i,
|
|
timelineStartPts,
|
|
event = {
|
|
tags: {},
|
|
captions: [],
|
|
metadata: []
|
|
};
|
|
|
|
if (this.pendingTracks < this.numberOfTracks) {
|
|
return;
|
|
}
|
|
|
|
if (this.videoTrack) {
|
|
timelineStartPts = this.videoTrack.timelineStartInfo.pts;
|
|
} else if (this.audioTrack) {
|
|
timelineStartPts = this.audioTrack.timelineStartInfo.pts;
|
|
}
|
|
|
|
event.tags.videoTags = this.videoTags;
|
|
event.tags.audioTags = this.audioTags;
|
|
|
|
// Translate caption PTS times into second offsets into the
|
|
// video timeline for the segment
|
|
for (i = 0; i < this.pendingCaptions.length; i++) {
|
|
caption = this.pendingCaptions[i];
|
|
caption.startTime = caption.startPts - timelineStartPts;
|
|
caption.startTime /= 90e3;
|
|
caption.endTime = caption.endPts - timelineStartPts;
|
|
caption.endTime /= 90e3;
|
|
event.captions.push(caption);
|
|
}
|
|
|
|
// Translate ID3 frame PTS times into second offsets into the
|
|
// video timeline for the segment
|
|
for (i = 0; i < this.pendingMetadata.length; i++) {
|
|
id3 = this.pendingMetadata[i];
|
|
id3.cueTime = id3.pts - timelineStartPts;
|
|
id3.cueTime /= 90e3;
|
|
event.metadata.push(id3);
|
|
}
|
|
// We add this to every single emitted segment even though we only need
|
|
// it for the first
|
|
event.metadata.dispatchType = this.metadataStream.dispatchType;
|
|
|
|
// Reset stream state
|
|
this.videoTrack = null;
|
|
this.audioTrack = null;
|
|
this.videoTags = [];
|
|
this.audioTags = [];
|
|
this.pendingCaptions.length = 0;
|
|
this.pendingMetadata.length = 0;
|
|
this.pendingTracks = 0;
|
|
|
|
// Emit the final segment
|
|
this.trigger('data', event);
|
|
|
|
this.trigger('done');
|
|
};
|
|
|
|
/**
|
|
* An object that incrementally transmuxes MPEG2 Trasport Stream
|
|
* chunks into an FLV.
|
|
*/
|
|
Transmuxer = function(options) {
|
|
var
|
|
self = this,
|
|
videoTrack,
|
|
audioTrack,
|
|
|
|
packetStream, parseStream, elementaryStream,
|
|
adtsStream, h264Stream,
|
|
videoSegmentStream, audioSegmentStream, captionStream,
|
|
coalesceStream;
|
|
|
|
Transmuxer.prototype.init.call(this);
|
|
|
|
options = options || {};
|
|
|
|
// expose the metadata stream
|
|
this.metadataStream = new m2ts.MetadataStream();
|
|
|
|
options.metadataStream = this.metadataStream;
|
|
|
|
// set up the parsing pipeline
|
|
packetStream = new m2ts.TransportPacketStream();
|
|
parseStream = new m2ts.TransportParseStream();
|
|
elementaryStream = new m2ts.ElementaryStream();
|
|
adtsStream = new AdtsStream();
|
|
h264Stream = new H264Stream();
|
|
coalesceStream = new CoalesceStream(options);
|
|
|
|
// disassemble MPEG2-TS packets into elementary streams
|
|
packetStream
|
|
.pipe(parseStream)
|
|
.pipe(elementaryStream);
|
|
|
|
// !!THIS ORDER IS IMPORTANT!!
|
|
// demux the streams
|
|
elementaryStream
|
|
.pipe(h264Stream);
|
|
elementaryStream
|
|
.pipe(adtsStream);
|
|
|
|
elementaryStream
|
|
.pipe(this.metadataStream)
|
|
.pipe(coalesceStream);
|
|
// if CEA-708 parsing is available, hook up a caption stream
|
|
captionStream = new m2ts.CaptionStream();
|
|
h264Stream.pipe(captionStream)
|
|
.pipe(coalesceStream);
|
|
|
|
// hook up the segment streams once track metadata is delivered
|
|
elementaryStream.on('data', function(data) {
|
|
var i, videoTrack, audioTrack;
|
|
|
|
if (data.type === 'metadata') {
|
|
i = data.tracks.length;
|
|
|
|
// scan the tracks listed in the metadata
|
|
while (i--) {
|
|
if (data.tracks[i].type === 'video') {
|
|
videoTrack = data.tracks[i];
|
|
} else if (data.tracks[i].type === 'audio') {
|
|
audioTrack = data.tracks[i];
|
|
}
|
|
}
|
|
|
|
// hook up the video segment stream to the first track with h264 data
|
|
if (videoTrack && !videoSegmentStream) {
|
|
coalesceStream.numberOfTracks++;
|
|
videoSegmentStream = new VideoSegmentStream(videoTrack);
|
|
|
|
// Set up the final part of the video pipeline
|
|
h264Stream
|
|
.pipe(videoSegmentStream)
|
|
.pipe(coalesceStream);
|
|
}
|
|
|
|
if (audioTrack && !audioSegmentStream) {
|
|
// hook up the audio segment stream to the first track with aac data
|
|
coalesceStream.numberOfTracks++;
|
|
audioSegmentStream = new AudioSegmentStream(audioTrack);
|
|
|
|
// Set up the final part of the audio pipeline
|
|
adtsStream
|
|
.pipe(audioSegmentStream)
|
|
.pipe(coalesceStream);
|
|
}
|
|
}
|
|
});
|
|
|
|
// feed incoming data to the front of the parsing pipeline
|
|
this.push = function(data) {
|
|
packetStream.push(data);
|
|
};
|
|
|
|
// flush any buffered data
|
|
this.flush = function() {
|
|
// Start at the top of the pipeline and flush all pending work
|
|
packetStream.flush();
|
|
};
|
|
|
|
// Re-emit any data coming from the coalesce stream to the outside world
|
|
coalesceStream.on('data', function (event) {
|
|
self.trigger('data', event);
|
|
});
|
|
|
|
// Let the consumer know we have finished flushing the entire pipeline
|
|
coalesceStream.on('done', function () {
|
|
self.trigger('done');
|
|
});
|
|
|
|
// For information on the FLV format, see
|
|
// http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf.
|
|
// Technically, this function returns the header and a metadata FLV tag
|
|
// if duration is greater than zero
|
|
// duration in seconds
|
|
// @return {object} the bytes of the FLV header as a Uint8Array
|
|
this.getFlvHeader = function(duration, audio, video) { // :ByteArray {
|
|
var
|
|
headBytes = new Uint8Array(3 + 1 + 1 + 4),
|
|
head = new DataView(headBytes.buffer),
|
|
metadata,
|
|
result,
|
|
metadataLength;
|
|
|
|
// default arguments
|
|
duration = duration || 0;
|
|
audio = audio === undefined? true : audio;
|
|
video = video === undefined? true : video;
|
|
|
|
// signature
|
|
head.setUint8(0, 0x46); // 'F'
|
|
head.setUint8(1, 0x4c); // 'L'
|
|
head.setUint8(2, 0x56); // 'V'
|
|
|
|
// version
|
|
head.setUint8(3, 0x01);
|
|
|
|
// flags
|
|
head.setUint8(4, (audio ? 0x04 : 0x00) | (video ? 0x01 : 0x00));
|
|
|
|
// data offset, should be 9 for FLV v1
|
|
head.setUint32(5, headBytes.byteLength);
|
|
|
|
// init the first FLV tag
|
|
if (duration <= 0) {
|
|
// no duration available so just write the first field of the first
|
|
// FLV tag
|
|
result = new Uint8Array(headBytes.byteLength + 4);
|
|
result.set(headBytes);
|
|
result.set([0, 0, 0, 0], headBytes.byteLength);
|
|
return result;
|
|
}
|
|
|
|
// write out the duration metadata tag
|
|
metadata = new FlvTag(FlvTag.METADATA_TAG);
|
|
metadata.pts = metadata.dts = 0;
|
|
metadata.writeMetaDataDouble("duration", duration);
|
|
metadataLength = metadata.finalize().length;
|
|
result = new Uint8Array(headBytes.byteLength + metadataLength);
|
|
result.set(headBytes);
|
|
result.set(head.byteLength, metadataLength);
|
|
|
|
return result;
|
|
};
|
|
};
|
|
Transmuxer.prototype = new Stream();
|
|
|
|
// forward compatibility
|
|
module.exports = Transmuxer;
|
|
|
|
},{"../codecs/adts.js":37,"../codecs/h264":38,"../m2ts/m2ts.js":46,"../utils/stream.js":55,"./flv-tag.js":40}],43:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var muxjs = {
|
|
codecs: require('./codecs'),
|
|
mp4: require('./mp4'),
|
|
flv: require('./flv'),
|
|
mp2t: require('./m2ts'),
|
|
};
|
|
module.exports = muxjs;
|
|
|
|
},{"./codecs":39,"./flv":41,"./m2ts":45,"./mp4":49}],44:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2015 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* Reads in-band caption information from a video elementary
|
|
* stream. Captions must follow the CEA-708 standard for injection
|
|
* into an MPEG-2 transport streams.
|
|
* @see https://en.wikipedia.org/wiki/CEA-708
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
// -----------------
|
|
// Link To Transport
|
|
// -----------------
|
|
|
|
// Supplemental enhancement information (SEI) NAL units have a
|
|
// payload type field to indicate how they are to be
|
|
// interpreted. CEAS-708 caption content is always transmitted with
|
|
// payload type 0x04.
|
|
var USER_DATA_REGISTERED_ITU_T_T35 = 4,
|
|
RBSP_TRAILING_BITS = 128,
|
|
Stream = require('../utils/stream');
|
|
|
|
/**
|
|
* Parse a supplemental enhancement information (SEI) NAL unit.
|
|
* Stops parsing once a message of type ITU T T35 has been found.
|
|
*
|
|
* @param bytes {Uint8Array} the bytes of a SEI NAL unit
|
|
* @return {object} the parsed SEI payload
|
|
* @see Rec. ITU-T H.264, 7.3.2.3.1
|
|
*/
|
|
var parseSei = function(bytes) {
|
|
var
|
|
i = 0,
|
|
result = {
|
|
payloadType: -1,
|
|
payloadSize: 0,
|
|
},
|
|
payloadType = 0,
|
|
payloadSize = 0;
|
|
|
|
// go through the sei_rbsp parsing each each individual sei_message
|
|
while (i < bytes.byteLength) {
|
|
// stop once we have hit the end of the sei_rbsp
|
|
if (bytes[i] === RBSP_TRAILING_BITS) {
|
|
break;
|
|
}
|
|
|
|
// Parse payload type
|
|
while (bytes[i] === 0xFF) {
|
|
payloadType += 255;
|
|
i++;
|
|
}
|
|
payloadType += bytes[i++];
|
|
|
|
// Parse payload size
|
|
while (bytes[i] === 0xFF) {
|
|
payloadSize += 255;
|
|
i++;
|
|
}
|
|
payloadSize += bytes[i++];
|
|
|
|
// this sei_message is a 608/708 caption so save it and break
|
|
// there can only ever be one caption message in a frame's sei
|
|
if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {
|
|
result.payloadType = payloadType;
|
|
result.payloadSize = payloadSize;
|
|
result.payload = bytes.subarray(i, i + payloadSize);
|
|
break;
|
|
}
|
|
|
|
// skip the payload and parse the next message
|
|
i += payloadSize;
|
|
payloadType = 0;
|
|
payloadSize = 0;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
// see ANSI/SCTE 128-1 (2013), section 8.1
|
|
var parseUserData = function(sei) {
|
|
// itu_t_t35_contry_code must be 181 (United States) for
|
|
// captions
|
|
if (sei.payload[0] !== 181) {
|
|
return null;
|
|
}
|
|
|
|
// itu_t_t35_provider_code should be 49 (ATSC) for captions
|
|
if (((sei.payload[1] << 8) | sei.payload[2]) !== 49) {
|
|
return null;
|
|
}
|
|
|
|
// the user_identifier should be "GA94" to indicate ATSC1 data
|
|
if (String.fromCharCode(sei.payload[3],
|
|
sei.payload[4],
|
|
sei.payload[5],
|
|
sei.payload[6]) !== 'GA94') {
|
|
return null;
|
|
}
|
|
|
|
// finally, user_data_type_code should be 0x03 for caption data
|
|
if (sei.payload[7] !== 0x03) {
|
|
return null;
|
|
}
|
|
|
|
// return the user_data_type_structure and strip the trailing
|
|
// marker bits
|
|
return sei.payload.subarray(8, sei.payload.length - 1);
|
|
};
|
|
|
|
// see CEA-708-D, section 4.4
|
|
var parseCaptionPackets = function(pts, userData) {
|
|
var results = [], i, count, offset, data;
|
|
|
|
// if this is just filler, return immediately
|
|
if (!(userData[0] & 0x40)) {
|
|
return results;
|
|
}
|
|
|
|
// parse out the cc_data_1 and cc_data_2 fields
|
|
count = userData[0] & 0x1f;
|
|
for (i = 0; i < count; i++) {
|
|
offset = i * 3;
|
|
data = {
|
|
type: userData[offset + 2] & 0x03,
|
|
pts: pts
|
|
};
|
|
|
|
// capture cc data when cc_valid is 1
|
|
if (userData[offset + 2] & 0x04) {
|
|
data.ccData = (userData[offset + 3] << 8) | userData[offset + 4];
|
|
results.push(data);
|
|
}
|
|
}
|
|
return results;
|
|
};
|
|
|
|
var CaptionStream = function() {
|
|
var self = this;
|
|
CaptionStream.prototype.init.call(this);
|
|
|
|
this.captionPackets_ = [];
|
|
|
|
this.field1_ = new Cea608Stream();
|
|
|
|
// forward data and done events from field1_ to this CaptionStream
|
|
this.field1_.on('data', this.trigger.bind(this, 'data'));
|
|
this.field1_.on('done', this.trigger.bind(this, 'done'));
|
|
};
|
|
CaptionStream.prototype = new Stream();
|
|
CaptionStream.prototype.push = function(event) {
|
|
var sei, userData, captionPackets;
|
|
|
|
// only examine SEI NALs
|
|
if (event.nalUnitType !== 'sei_rbsp') {
|
|
return;
|
|
}
|
|
|
|
// parse the sei
|
|
sei = parseSei(event.escapedRBSP);
|
|
|
|
// ignore everything but user_data_registered_itu_t_t35
|
|
if (sei.payloadType !== USER_DATA_REGISTERED_ITU_T_T35) {
|
|
return;
|
|
}
|
|
|
|
// parse out the user data payload
|
|
userData = parseUserData(sei);
|
|
|
|
// ignore unrecognized userData
|
|
if (!userData) {
|
|
return;
|
|
}
|
|
|
|
// parse out CC data packets and save them for later
|
|
this.captionPackets_ = this.captionPackets_.concat(parseCaptionPackets(event.pts, userData));
|
|
};
|
|
|
|
CaptionStream.prototype.flush = function () {
|
|
// make sure we actually parsed captions before proceeding
|
|
if (!this.captionPackets_.length) {
|
|
this.field1_.flush();
|
|
return;
|
|
}
|
|
|
|
// sort caption byte-pairs based on their PTS values
|
|
this.captionPackets_.sort(function(a, b) {
|
|
return a.pts - b.pts;
|
|
});
|
|
|
|
// Push each caption into Cea608Stream
|
|
this.captionPackets_.forEach(this.field1_.push, this.field1_);
|
|
|
|
this.captionPackets_.length = 0;
|
|
this.field1_.flush();
|
|
return;
|
|
};
|
|
// ----------------------
|
|
// Session to Application
|
|
// ----------------------
|
|
|
|
var BASIC_CHARACTER_TRANSLATION = {
|
|
0x2a: 0xe1,
|
|
0x5c: 0xe9,
|
|
0x5e: 0xed,
|
|
0x5f: 0xf3,
|
|
0x60: 0xfa,
|
|
0x7b: 0xe7,
|
|
0x7c: 0xf7,
|
|
0x7d: 0xd1,
|
|
0x7e: 0xf1,
|
|
0x7f: 0x2588
|
|
};
|
|
|
|
var getCharFromCode = function(code) {
|
|
if(code === null) {
|
|
return '';
|
|
}
|
|
code = BASIC_CHARACTER_TRANSLATION[code] || code;
|
|
return String.fromCharCode(code);
|
|
};
|
|
|
|
// Constants for the byte codes recognized by Cea608Stream. This
|
|
// list is not exhaustive. For a more comprehensive listing and
|
|
// semantics see
|
|
// http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf
|
|
var PADDING = 0x0000,
|
|
|
|
// Pop-on Mode
|
|
RESUME_CAPTION_LOADING = 0x1420,
|
|
END_OF_CAPTION = 0x142f,
|
|
|
|
// Roll-up Mode
|
|
ROLL_UP_2_ROWS = 0x1425,
|
|
ROLL_UP_3_ROWS = 0x1426,
|
|
ROLL_UP_4_ROWS = 0x1427,
|
|
RESUME_DIRECT_CAPTIONING = 0x1429,
|
|
CARRIAGE_RETURN = 0x142d,
|
|
// Erasure
|
|
BACKSPACE = 0x1421,
|
|
ERASE_DISPLAYED_MEMORY = 0x142c,
|
|
ERASE_NON_DISPLAYED_MEMORY = 0x142e;
|
|
|
|
// the index of the last row in a CEA-608 display buffer
|
|
var BOTTOM_ROW = 14;
|
|
// CEA-608 captions are rendered onto a 34x15 matrix of character
|
|
// cells. The "bottom" row is the last element in the outer array.
|
|
var createDisplayBuffer = function() {
|
|
var result = [], i = BOTTOM_ROW + 1;
|
|
while (i--) {
|
|
result.push('');
|
|
}
|
|
return result;
|
|
};
|
|
|
|
var Cea608Stream = function() {
|
|
Cea608Stream.prototype.init.call(this);
|
|
|
|
this.mode_ = 'popOn';
|
|
// When in roll-up mode, the index of the last row that will
|
|
// actually display captions. If a caption is shifted to a row
|
|
// with a lower index than this, it is cleared from the display
|
|
// buffer
|
|
this.topRow_ = 0;
|
|
this.startPts_ = 0;
|
|
this.displayed_ = createDisplayBuffer();
|
|
this.nonDisplayed_ = createDisplayBuffer();
|
|
this.lastControlCode_ = null;
|
|
|
|
this.push = function(packet) {
|
|
// Ignore other channels
|
|
if (packet.type !== 0) {
|
|
return;
|
|
}
|
|
var data, swap, char0, char1;
|
|
// remove the parity bits
|
|
data = packet.ccData & 0x7f7f;
|
|
|
|
// ignore duplicate control codes
|
|
if (data === this.lastControlCode_) {
|
|
this.lastControlCode_ = null;
|
|
return;
|
|
}
|
|
|
|
// Store control codes
|
|
if ((data & 0xf000) === 0x1000) {
|
|
this.lastControlCode_ = data;
|
|
} else {
|
|
this.lastControlCode_ = null;
|
|
}
|
|
|
|
switch (data) {
|
|
case PADDING:
|
|
break;
|
|
case RESUME_CAPTION_LOADING:
|
|
this.mode_ = 'popOn';
|
|
break;
|
|
case END_OF_CAPTION:
|
|
// if a caption was being displayed, it's gone now
|
|
this.flushDisplayed(packet.pts);
|
|
|
|
// flip memory
|
|
swap = this.displayed_;
|
|
this.displayed_ = this.nonDisplayed_;
|
|
this.nonDisplayed_ = swap;
|
|
|
|
// start measuring the time to display the caption
|
|
this.startPts_ = packet.pts;
|
|
break;
|
|
|
|
case ROLL_UP_2_ROWS:
|
|
this.topRow_ = BOTTOM_ROW - 1;
|
|
this.mode_ = 'rollUp';
|
|
break;
|
|
case ROLL_UP_3_ROWS:
|
|
this.topRow_ = BOTTOM_ROW - 2;
|
|
this.mode_ = 'rollUp';
|
|
break;
|
|
case ROLL_UP_4_ROWS:
|
|
this.topRow_ = BOTTOM_ROW - 3;
|
|
this.mode_ = 'rollUp';
|
|
break;
|
|
case CARRIAGE_RETURN:
|
|
this.flushDisplayed(packet.pts);
|
|
this.shiftRowsUp_();
|
|
this.startPts_ = packet.pts;
|
|
break;
|
|
|
|
case BACKSPACE:
|
|
if (this.mode_ === 'popOn') {
|
|
this.nonDisplayed_[BOTTOM_ROW] = this.nonDisplayed_[BOTTOM_ROW].slice(0, -1);
|
|
} else {
|
|
this.displayed_[BOTTOM_ROW] = this.displayed_[BOTTOM_ROW].slice(0, -1);
|
|
}
|
|
break;
|
|
case ERASE_DISPLAYED_MEMORY:
|
|
this.flushDisplayed(packet.pts);
|
|
this.displayed_ = createDisplayBuffer();
|
|
break;
|
|
case ERASE_NON_DISPLAYED_MEMORY:
|
|
this.nonDisplayed_ = createDisplayBuffer();
|
|
break;
|
|
default:
|
|
char0 = data >>> 8;
|
|
char1 = data & 0xff;
|
|
|
|
// Look for a Channel 1 Preamble Address Code
|
|
if (char0 >= 0x10 && char0 <= 0x17 &&
|
|
char1 >= 0x40 && char1 <= 0x7F &&
|
|
(char0 !== 0x10 || char1 < 0x60)) {
|
|
// Follow Safari's lead and replace the PAC with a space
|
|
char0 = 0x20;
|
|
// we only want one space so make the second character null
|
|
// which will get become '' in getCharFromCode
|
|
char1 = null;
|
|
}
|
|
|
|
// Look for special character sets
|
|
if ((char0 === 0x11 || char0 === 0x19) &&
|
|
(char1 >= 0x30 && char1 <= 0x3F)) {
|
|
// Put in eigth note and space
|
|
char0 = 0x266A;
|
|
char1 = '';
|
|
}
|
|
|
|
// ignore unsupported control codes
|
|
if ((char0 & 0xf0) === 0x10) {
|
|
return;
|
|
}
|
|
|
|
// character handling is dependent on the current mode
|
|
this[this.mode_](packet.pts, char0, char1);
|
|
break;
|
|
}
|
|
};
|
|
};
|
|
Cea608Stream.prototype = new Stream();
|
|
// Trigger a cue point that captures the current state of the
|
|
// display buffer
|
|
Cea608Stream.prototype.flushDisplayed = function(pts) {
|
|
var content = this.displayed_
|
|
// remove spaces from the start and end of the string
|
|
.map(function(row) { return row.trim(); })
|
|
// remove empty rows
|
|
.filter(function(row) { return row.length; })
|
|
// combine all text rows to display in one cue
|
|
.join('\n');
|
|
|
|
if (content.length) {
|
|
this.trigger('data', {
|
|
startPts: this.startPts_,
|
|
endPts: pts,
|
|
text: content
|
|
});
|
|
}
|
|
};
|
|
|
|
// Mode Implementations
|
|
Cea608Stream.prototype.popOn = function(pts, char0, char1) {
|
|
var baseRow = this.nonDisplayed_[BOTTOM_ROW];
|
|
|
|
// buffer characters
|
|
baseRow += getCharFromCode(char0);
|
|
baseRow += getCharFromCode(char1);
|
|
this.nonDisplayed_[BOTTOM_ROW] = baseRow;
|
|
};
|
|
|
|
Cea608Stream.prototype.rollUp = function(pts, char0, char1) {
|
|
var baseRow = this.displayed_[BOTTOM_ROW];
|
|
if (baseRow === '') {
|
|
// we're starting to buffer new display input, so flush out the
|
|
// current display
|
|
this.flushDisplayed(pts);
|
|
|
|
this.startPts_ = pts;
|
|
}
|
|
|
|
baseRow += getCharFromCode(char0);
|
|
baseRow += getCharFromCode(char1);
|
|
|
|
this.displayed_[BOTTOM_ROW] = baseRow;
|
|
};
|
|
Cea608Stream.prototype.shiftRowsUp_ = function() {
|
|
var i;
|
|
// clear out inactive rows
|
|
for (i = 0; i < this.topRow_; i++) {
|
|
this.displayed_[i] = '';
|
|
}
|
|
// shift displayed rows up
|
|
for (i = this.topRow_; i < BOTTOM_ROW; i++) {
|
|
this.displayed_[i] = this.displayed_[i + 1];
|
|
}
|
|
// clear out the bottom row
|
|
this.displayed_[BOTTOM_ROW] = '';
|
|
};
|
|
|
|
// exports
|
|
module.exports = {
|
|
CaptionStream: CaptionStream,
|
|
Cea608Stream: Cea608Stream,
|
|
};
|
|
|
|
|
|
},{"../utils/stream":55}],45:[function(require,module,exports){
|
|
module.exports = require('./m2ts');
|
|
|
|
},{"./m2ts":46}],46:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2015 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* A stream-based mp2t to mp4 converter. This utility can be used to
|
|
* deliver mp4s to a SourceBuffer on platforms that support native
|
|
* Media Source Extensions.
|
|
*/
|
|
'use strict';
|
|
var Stream = require('../utils/stream.js'),
|
|
CaptionStream = require('./caption-stream'),
|
|
StreamTypes = require('./stream-types');
|
|
|
|
var Stream = require('../utils/stream.js');
|
|
var m2tsStreamTypes = require('./stream-types.js');
|
|
|
|
// object types
|
|
var
|
|
TransportPacketStream, TransportParseStream, ElementaryStream,
|
|
AacStream, H264Stream, NalByteStream;
|
|
|
|
// constants
|
|
var
|
|
MP2T_PACKET_LENGTH = 188, // bytes
|
|
SYNC_BYTE = 0x47,
|
|
|
|
/**
|
|
* Splits an incoming stream of binary data into MPEG-2 Transport
|
|
* Stream packets.
|
|
*/
|
|
TransportPacketStream = function() {
|
|
var
|
|
buffer = new Uint8Array(MP2T_PACKET_LENGTH),
|
|
bytesInBuffer = 0;
|
|
|
|
TransportPacketStream.prototype.init.call(this);
|
|
|
|
// Deliver new bytes to the stream.
|
|
|
|
this.push = function(bytes) {
|
|
var
|
|
i = 0,
|
|
startIndex = 0,
|
|
endIndex = MP2T_PACKET_LENGTH,
|
|
everything;
|
|
|
|
// If there are bytes remaining from the last segment, prepend them to the
|
|
// bytes that were pushed in
|
|
if (bytesInBuffer) {
|
|
everything = new Uint8Array(bytes.byteLength + bytesInBuffer);
|
|
everything.set(buffer.subarray(0, bytesInBuffer));
|
|
everything.set(bytes, bytesInBuffer);
|
|
bytesInBuffer = 0;
|
|
} else {
|
|
everything = bytes;
|
|
}
|
|
|
|
// While we have enough data for a packet
|
|
while (endIndex < everything.byteLength) {
|
|
// Look for a pair of start and end sync bytes in the data..
|
|
if (everything[startIndex] === SYNC_BYTE && everything[endIndex] === SYNC_BYTE) {
|
|
// We found a packet so emit it and jump one whole packet forward in
|
|
// the stream
|
|
this.trigger('data', everything.subarray(startIndex, endIndex));
|
|
startIndex += MP2T_PACKET_LENGTH;
|
|
endIndex += MP2T_PACKET_LENGTH;
|
|
continue;
|
|
}
|
|
// If we get here, we have somehow become de-synchronized and we need to step
|
|
// forward one byte at a time until we find a pair of sync bytes that denote
|
|
// a packet
|
|
startIndex++;
|
|
endIndex++;
|
|
}
|
|
|
|
// If there was some data left over at the end of the segment that couldn't
|
|
// possibly be a whole packet, keep it because it might be the start of a packet
|
|
// that continues in the next segment
|
|
if (startIndex < everything.byteLength) {
|
|
buffer.set(everything.subarray(startIndex), 0);
|
|
bytesInBuffer = everything.byteLength - startIndex;
|
|
}
|
|
};
|
|
|
|
this.flush = function () {
|
|
// If the buffer contains a whole packet when we are being flushed, emit it
|
|
// and empty the buffer. Otherwise hold onto the data because it may be
|
|
// important for decoding the next segment
|
|
if (bytesInBuffer === MP2T_PACKET_LENGTH && buffer[0] === SYNC_BYTE) {
|
|
this.trigger('data', buffer);
|
|
bytesInBuffer = 0;
|
|
}
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
TransportPacketStream.prototype = new Stream();
|
|
|
|
/**
|
|
* Accepts an MP2T TransportPacketStream and emits data events with parsed
|
|
* forms of the individual transport stream packets.
|
|
*/
|
|
TransportParseStream = function() {
|
|
var parsePsi, parsePat, parsePmt, parsePes, self;
|
|
TransportParseStream.prototype.init.call(this);
|
|
self = this;
|
|
|
|
this.packetsWaitingForPmt = [];
|
|
this.programMapTable = undefined;
|
|
|
|
parsePsi = function(payload, psi) {
|
|
var offset = 0;
|
|
|
|
// PSI packets may be split into multiple sections and those
|
|
// sections may be split into multiple packets. If a PSI
|
|
// section starts in this packet, the payload_unit_start_indicator
|
|
// will be true and the first byte of the payload will indicate
|
|
// the offset from the current position to the start of the
|
|
// section.
|
|
if (psi.payloadUnitStartIndicator) {
|
|
offset += payload[offset] + 1;
|
|
}
|
|
|
|
if (psi.type === 'pat') {
|
|
parsePat(payload.subarray(offset), psi);
|
|
} else {
|
|
parsePmt(payload.subarray(offset), psi);
|
|
}
|
|
};
|
|
|
|
parsePat = function(payload, pat) {
|
|
pat.section_number = payload[7];
|
|
pat.last_section_number = payload[8];
|
|
|
|
// skip the PSI header and parse the first PMT entry
|
|
self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];
|
|
pat.pmtPid = self.pmtPid;
|
|
};
|
|
|
|
/**
|
|
* Parse out the relevant fields of a Program Map Table (PMT).
|
|
* @param payload {Uint8Array} the PMT-specific portion of an MP2T
|
|
* packet. The first byte in this array should be the table_id
|
|
* field.
|
|
* @param pmt {object} the object that should be decorated with
|
|
* fields parsed from the PMT.
|
|
*/
|
|
parsePmt = function(payload, pmt) {
|
|
var sectionLength, tableEnd, programInfoLength, offset;
|
|
|
|
// PMTs can be sent ahead of the time when they should actually
|
|
// take effect. We don't believe this should ever be the case
|
|
// for HLS but we'll ignore "forward" PMT declarations if we see
|
|
// them. Future PMT declarations have the current_next_indicator
|
|
// set to zero.
|
|
if (!(payload[5] & 0x01)) {
|
|
return;
|
|
}
|
|
|
|
// overwrite any existing program map table
|
|
self.programMapTable = {};
|
|
|
|
// the mapping table ends at the end of the current section
|
|
sectionLength = (payload[1] & 0x0f) << 8 | payload[2];
|
|
tableEnd = 3 + sectionLength - 4;
|
|
|
|
// to determine where the table is, we have to figure out how
|
|
// long the program info descriptors are
|
|
programInfoLength = (payload[10] & 0x0f) << 8 | payload[11];
|
|
|
|
// advance the offset to the first entry in the mapping table
|
|
offset = 12 + programInfoLength;
|
|
while (offset < tableEnd) {
|
|
// add an entry that maps the elementary_pid to the stream_type
|
|
self.programMapTable[(payload[offset + 1] & 0x1F) << 8 | payload[offset + 2]] = payload[offset];
|
|
|
|
// move to the next table entry
|
|
// skip past the elementary stream descriptors, if present
|
|
offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;
|
|
}
|
|
|
|
// record the map on the packet as well
|
|
pmt.programMapTable = self.programMapTable;
|
|
|
|
// if there are any packets waiting for a PMT to be found, process them now
|
|
while (self.packetsWaitingForPmt.length) {
|
|
self.processPes_.apply(self, self.packetsWaitingForPmt.shift());
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Deliver a new MP2T packet to the stream.
|
|
*/
|
|
this.push = function(packet) {
|
|
var
|
|
result = {},
|
|
offset = 4;
|
|
|
|
result.payloadUnitStartIndicator = !!(packet[1] & 0x40);
|
|
|
|
// pid is a 13-bit field starting at the last bit of packet[1]
|
|
result.pid = packet[1] & 0x1f;
|
|
result.pid <<= 8;
|
|
result.pid |= packet[2];
|
|
|
|
// if an adaption field is present, its length is specified by the
|
|
// fifth byte of the TS packet header. The adaptation field is
|
|
// used to add stuffing to PES packets that don't fill a complete
|
|
// TS packet, and to specify some forms of timing and control data
|
|
// that we do not currently use.
|
|
if (((packet[3] & 0x30) >>> 4) > 0x01) {
|
|
offset += packet[offset] + 1;
|
|
}
|
|
|
|
// parse the rest of the packet based on the type
|
|
if (result.pid === 0) {
|
|
result.type = 'pat';
|
|
parsePsi(packet.subarray(offset), result);
|
|
this.trigger('data', result);
|
|
} else if (result.pid === this.pmtPid) {
|
|
result.type = 'pmt';
|
|
parsePsi(packet.subarray(offset), result);
|
|
this.trigger('data', result);
|
|
} else if (this.programMapTable === undefined) {
|
|
// When we have not seen a PMT yet, defer further processing of
|
|
// PES packets until one has been parsed
|
|
this.packetsWaitingForPmt.push([packet, offset, result]);
|
|
} else {
|
|
this.processPes_(packet, offset, result);
|
|
}
|
|
};
|
|
|
|
this.processPes_ = function (packet, offset, result) {
|
|
result.streamType = this.programMapTable[result.pid];
|
|
result.type = 'pes';
|
|
result.data = packet.subarray(offset);
|
|
|
|
this.trigger('data', result);
|
|
};
|
|
|
|
};
|
|
TransportParseStream.prototype = new Stream();
|
|
TransportParseStream.STREAM_TYPES = {
|
|
h264: 0x1b,
|
|
adts: 0x0f
|
|
};
|
|
|
|
/**
|
|
* Reconsistutes program elementary stream (PES) packets from parsed
|
|
* transport stream packets. That is, if you pipe an
|
|
* mp2t.TransportParseStream into a mp2t.ElementaryStream, the output
|
|
* events will be events which capture the bytes for individual PES
|
|
* packets plus relevant metadata that has been extracted from the
|
|
* container.
|
|
*/
|
|
ElementaryStream = function() {
|
|
var
|
|
// PES packet fragments
|
|
video = {
|
|
data: [],
|
|
size: 0
|
|
},
|
|
audio = {
|
|
data: [],
|
|
size: 0
|
|
},
|
|
timedMetadata = {
|
|
data: [],
|
|
size: 0
|
|
},
|
|
parsePes = function(payload, pes) {
|
|
var ptsDtsFlags;
|
|
|
|
// find out if this packets starts a new keyframe
|
|
pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0;
|
|
// PES packets may be annotated with a PTS value, or a PTS value
|
|
// and a DTS value. Determine what combination of values is
|
|
// available to work with.
|
|
ptsDtsFlags = payload[7];
|
|
|
|
// PTS and DTS are normally stored as a 33-bit number. Javascript
|
|
// performs all bitwise operations on 32-bit integers but javascript
|
|
// supports a much greater range (52-bits) of integer using standard
|
|
// mathematical operations.
|
|
// We construct a 31-bit value using bitwise operators over the 31
|
|
// most significant bits and then multiply by 4 (equal to a left-shift
|
|
// of 2) before we add the final 2 least significant bits of the
|
|
// timestamp (equal to an OR.)
|
|
if (ptsDtsFlags & 0xC0) {
|
|
// the PTS and DTS are not written out directly. For information
|
|
// on how they are encoded, see
|
|
// http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
|
|
pes.pts = (payload[9] & 0x0E) << 27
|
|
| (payload[10] & 0xFF) << 20
|
|
| (payload[11] & 0xFE) << 12
|
|
| (payload[12] & 0xFF) << 5
|
|
| (payload[13] & 0xFE) >>> 3;
|
|
pes.pts *= 4; // Left shift by 2
|
|
pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs
|
|
pes.dts = pes.pts;
|
|
if (ptsDtsFlags & 0x40) {
|
|
pes.dts = (payload[14] & 0x0E ) << 27
|
|
| (payload[15] & 0xFF ) << 20
|
|
| (payload[16] & 0xFE ) << 12
|
|
| (payload[17] & 0xFF ) << 5
|
|
| (payload[18] & 0xFE ) >>> 3;
|
|
pes.dts *= 4; // Left shift by 2
|
|
pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs
|
|
}
|
|
}
|
|
|
|
// the data section starts immediately after the PES header.
|
|
// pes_header_data_length specifies the number of header bytes
|
|
// that follow the last byte of the field.
|
|
pes.data = payload.subarray(9 + payload[8]);
|
|
},
|
|
flushStream = function(stream, type) {
|
|
var
|
|
packetData = new Uint8Array(stream.size),
|
|
event = {
|
|
type: type
|
|
},
|
|
i = 0,
|
|
fragment;
|
|
|
|
// do nothing if there is no buffered data
|
|
if (!stream.data.length) {
|
|
return;
|
|
}
|
|
event.trackId = stream.data[0].pid;
|
|
|
|
// reassemble the packet
|
|
while (stream.data.length) {
|
|
fragment = stream.data.shift();
|
|
|
|
packetData.set(fragment.data, i);
|
|
i += fragment.data.byteLength;
|
|
}
|
|
|
|
// parse assembled packet's PES header
|
|
parsePes(packetData, event);
|
|
|
|
stream.size = 0;
|
|
|
|
self.trigger('data', event);
|
|
},
|
|
self;
|
|
|
|
ElementaryStream.prototype.init.call(this);
|
|
self = this;
|
|
|
|
this.push = function(data) {
|
|
({
|
|
pat: function() {
|
|
// we have to wait for the PMT to arrive as well before we
|
|
// have any meaningful metadata
|
|
},
|
|
pes: function() {
|
|
var stream, streamType;
|
|
|
|
switch (data.streamType) {
|
|
case StreamTypes.H264_STREAM_TYPE:
|
|
case m2tsStreamTypes.H264_STREAM_TYPE:
|
|
stream = video;
|
|
streamType = 'video';
|
|
break;
|
|
case StreamTypes.ADTS_STREAM_TYPE:
|
|
stream = audio;
|
|
streamType = 'audio';
|
|
break;
|
|
case StreamTypes.METADATA_STREAM_TYPE:
|
|
stream = timedMetadata;
|
|
streamType = 'timed-metadata';
|
|
break;
|
|
default:
|
|
// ignore unknown stream types
|
|
return;
|
|
}
|
|
|
|
// if a new packet is starting, we can flush the completed
|
|
// packet
|
|
if (data.payloadUnitStartIndicator) {
|
|
flushStream(stream, streamType);
|
|
}
|
|
|
|
// buffer this fragment until we are sure we've received the
|
|
// complete payload
|
|
stream.data.push(data);
|
|
stream.size += data.data.byteLength;
|
|
},
|
|
pmt: function() {
|
|
var
|
|
event = {
|
|
type: 'metadata',
|
|
tracks: []
|
|
},
|
|
programMapTable = data.programMapTable,
|
|
k,
|
|
track;
|
|
|
|
// translate streams to tracks
|
|
for (k in programMapTable) {
|
|
if (programMapTable.hasOwnProperty(k)) {
|
|
track = {
|
|
timelineStartInfo: {
|
|
baseMediaDecodeTime: 0
|
|
}
|
|
};
|
|
track.id = +k;
|
|
if (programMapTable[k] === m2tsStreamTypes.H264_STREAM_TYPE) {
|
|
track.codec = 'avc';
|
|
track.type = 'video';
|
|
} else if (programMapTable[k] === m2tsStreamTypes.ADTS_STREAM_TYPE) {
|
|
track.codec = 'adts';
|
|
track.type = 'audio';
|
|
}
|
|
event.tracks.push(track);
|
|
}
|
|
}
|
|
self.trigger('data', event);
|
|
}
|
|
})[data.type]();
|
|
};
|
|
|
|
/**
|
|
* Flush any remaining input. Video PES packets may be of variable
|
|
* length. Normally, the start of a new video packet can trigger the
|
|
* finalization of the previous packet. That is not possible if no
|
|
* more video is forthcoming, however. In that case, some other
|
|
* mechanism (like the end of the file) has to be employed. When it is
|
|
* clear that no additional data is forthcoming, calling this method
|
|
* will flush the buffered packets.
|
|
*/
|
|
this.flush = function() {
|
|
// !!THIS ORDER IS IMPORTANT!!
|
|
// video first then audio
|
|
flushStream(video, 'video');
|
|
flushStream(audio, 'audio');
|
|
flushStream(timedMetadata, 'timed-metadata');
|
|
this.trigger('done');
|
|
};
|
|
};
|
|
ElementaryStream.prototype = new Stream();
|
|
|
|
var m2ts = {
|
|
PAT_PID: 0x0000,
|
|
MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH,
|
|
TransportPacketStream: TransportPacketStream,
|
|
TransportParseStream: TransportParseStream,
|
|
ElementaryStream: ElementaryStream,
|
|
CaptionStream: CaptionStream.CaptionStream,
|
|
Cea608Stream: CaptionStream.Cea608Stream,
|
|
MetadataStream: require('./metadata-stream'),
|
|
};
|
|
|
|
for (var type in StreamTypes) {
|
|
if (StreamTypes.hasOwnProperty(type)) {
|
|
m2ts[type] = StreamTypes[type];
|
|
}
|
|
}
|
|
|
|
module.exports = m2ts;
|
|
|
|
},{"../utils/stream.js":55,"./caption-stream":44,"./metadata-stream":47,"./stream-types":48,"./stream-types.js":48}],47:[function(require,module,exports){
|
|
/**
|
|
* Accepts program elementary stream (PES) data events and parses out
|
|
* ID3 metadata from them, if present.
|
|
* @see http://id3.org/id3v2.3.0
|
|
*/
|
|
'use strict';
|
|
var
|
|
Stream = require('../utils/stream'),
|
|
StreamTypes = require('./stream-types'),
|
|
// return a percent-encoded representation of the specified byte range
|
|
// @see http://en.wikipedia.org/wiki/Percent-encoding
|
|
percentEncode = function(bytes, start, end) {
|
|
var i, result = '';
|
|
for (i = start; i < end; i++) {
|
|
result += '%' + ('00' + bytes[i].toString(16)).slice(-2);
|
|
}
|
|
return result;
|
|
},
|
|
// return the string representation of the specified byte range,
|
|
// interpreted as UTf-8.
|
|
parseUtf8 = function(bytes, start, end) {
|
|
return decodeURIComponent(percentEncode(bytes, start, end));
|
|
},
|
|
// return the string representation of the specified byte range,
|
|
// interpreted as ISO-8859-1.
|
|
parseIso88591 = function(bytes, start, end) {
|
|
return unescape(percentEncode(bytes, start, end)); // jshint ignore:line
|
|
},
|
|
parseSyncSafeInteger = function (data) {
|
|
return (data[0] << 21) |
|
|
(data[1] << 14) |
|
|
(data[2] << 7) |
|
|
(data[3]);
|
|
},
|
|
tagParsers = {
|
|
'TXXX': function(tag) {
|
|
var i;
|
|
if (tag.data[0] !== 3) {
|
|
// ignore frames with unrecognized character encodings
|
|
return;
|
|
}
|
|
|
|
for (i = 1; i < tag.data.length; i++) {
|
|
if (tag.data[i] === 0) {
|
|
// parse the text fields
|
|
tag.description = parseUtf8(tag.data, 1, i);
|
|
// do not include the null terminator in the tag value
|
|
tag.value = parseUtf8(tag.data, i + 1, tag.data.length - 1);
|
|
break;
|
|
}
|
|
}
|
|
tag.data = tag.value;
|
|
},
|
|
'WXXX': function(tag) {
|
|
var i;
|
|
if (tag.data[0] !== 3) {
|
|
// ignore frames with unrecognized character encodings
|
|
return;
|
|
}
|
|
|
|
for (i = 1; i < tag.data.length; i++) {
|
|
if (tag.data[i] === 0) {
|
|
// parse the description and URL fields
|
|
tag.description = parseUtf8(tag.data, 1, i);
|
|
tag.url = parseUtf8(tag.data, i + 1, tag.data.length);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
'PRIV': function(tag) {
|
|
var i;
|
|
|
|
for (i = 0; i < tag.data.length; i++) {
|
|
if (tag.data[i] === 0) {
|
|
// parse the description and URL fields
|
|
tag.owner = parseIso88591(tag.data, 0, i);
|
|
break;
|
|
}
|
|
}
|
|
tag.privateData = tag.data.subarray(i + 1);
|
|
tag.data = tag.privateData;
|
|
}
|
|
},
|
|
MetadataStream;
|
|
|
|
MetadataStream = function(options) {
|
|
var
|
|
settings = {
|
|
debug: !!(options && options.debug),
|
|
|
|
// the bytes of the program-level descriptor field in MP2T
|
|
// see ISO/IEC 13818-1:2013 (E), section 2.6 "Program and
|
|
// program element descriptors"
|
|
descriptor: options && options.descriptor
|
|
},
|
|
// the total size in bytes of the ID3 tag being parsed
|
|
tagSize = 0,
|
|
// tag data that is not complete enough to be parsed
|
|
buffer = [],
|
|
// the total number of bytes currently in the buffer
|
|
bufferSize = 0,
|
|
i;
|
|
|
|
MetadataStream.prototype.init.call(this);
|
|
|
|
// calculate the text track in-band metadata track dispatch type
|
|
// https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track
|
|
this.dispatchType = StreamTypes.METADATA_STREAM_TYPE.toString(16);
|
|
if (settings.descriptor) {
|
|
for (i = 0; i < settings.descriptor.length; i++) {
|
|
this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);
|
|
}
|
|
}
|
|
|
|
this.push = function(chunk) {
|
|
var tag, frameStart, frameSize, frame, i, frameHeader;
|
|
if (chunk.type !== 'timed-metadata') {
|
|
return;
|
|
}
|
|
|
|
// if data_alignment_indicator is set in the PES header,
|
|
// we must have the start of a new ID3 tag. Assume anything
|
|
// remaining in the buffer was malformed and throw it out
|
|
if (chunk.dataAlignmentIndicator) {
|
|
bufferSize = 0;
|
|
buffer.length = 0;
|
|
}
|
|
|
|
// ignore events that don't look like ID3 data
|
|
if (buffer.length === 0 &&
|
|
(chunk.data.length < 10 ||
|
|
chunk.data[0] !== 'I'.charCodeAt(0) ||
|
|
chunk.data[1] !== 'D'.charCodeAt(0) ||
|
|
chunk.data[2] !== '3'.charCodeAt(0))) {
|
|
if (settings.debug) {
|
|
console.log('Skipping unrecognized metadata packet');
|
|
}
|
|
return;
|
|
}
|
|
|
|
// add this chunk to the data we've collected so far
|
|
|
|
buffer.push(chunk);
|
|
bufferSize += chunk.data.byteLength;
|
|
|
|
// grab the size of the entire frame from the ID3 header
|
|
if (buffer.length === 1) {
|
|
// the frame size is transmitted as a 28-bit integer in the
|
|
// last four bytes of the ID3 header.
|
|
// The most significant bit of each byte is dropped and the
|
|
// results concatenated to recover the actual value.
|
|
tagSize = parseSyncSafeInteger(chunk.data.subarray(6, 10));
|
|
|
|
// ID3 reports the tag size excluding the header but it's more
|
|
// convenient for our comparisons to include it
|
|
tagSize += 10;
|
|
}
|
|
|
|
// if the entire frame has not arrived, wait for more data
|
|
if (bufferSize < tagSize) {
|
|
return;
|
|
}
|
|
|
|
// collect the entire frame so it can be parsed
|
|
tag = {
|
|
data: new Uint8Array(tagSize),
|
|
frames: [],
|
|
pts: buffer[0].pts,
|
|
dts: buffer[0].dts
|
|
};
|
|
for (i = 0; i < tagSize;) {
|
|
tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);
|
|
i += buffer[0].data.byteLength;
|
|
bufferSize -= buffer[0].data.byteLength;
|
|
buffer.shift();
|
|
}
|
|
|
|
// find the start of the first frame and the end of the tag
|
|
frameStart = 10;
|
|
if (tag.data[5] & 0x40) {
|
|
// advance the frame start past the extended header
|
|
frameStart += 4; // header size field
|
|
frameStart += parseSyncSafeInteger(tag.data.subarray(10, 14));
|
|
|
|
// clip any padding off the end
|
|
tagSize -= parseSyncSafeInteger(tag.data.subarray(16, 20));
|
|
}
|
|
|
|
// parse one or more ID3 frames
|
|
// http://id3.org/id3v2.3.0#ID3v2_frame_overview
|
|
do {
|
|
// determine the number of bytes in this frame
|
|
frameSize = parseSyncSafeInteger(tag.data.subarray(frameStart + 4, frameStart + 8));
|
|
if (frameSize < 1) {
|
|
return console.log('Malformed ID3 frame encountered. Skipping metadata parsing.');
|
|
}
|
|
frameHeader = String.fromCharCode(tag.data[frameStart],
|
|
tag.data[frameStart + 1],
|
|
tag.data[frameStart + 2],
|
|
tag.data[frameStart + 3]);
|
|
|
|
|
|
frame = {
|
|
id: frameHeader,
|
|
data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)
|
|
};
|
|
frame.key = frame.id;
|
|
if (tagParsers[frame.id]) {
|
|
tagParsers[frame.id](frame);
|
|
if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {
|
|
var
|
|
d = frame.data,
|
|
size = ((d[3] & 0x01) << 30) |
|
|
(d[4] << 22) |
|
|
(d[5] << 14) |
|
|
(d[6] << 6) |
|
|
(d[7] >>> 2);
|
|
|
|
size *= 4;
|
|
size += d[7] & 0x03;
|
|
frame.timeStamp = size;
|
|
this.trigger('timestamp', frame);
|
|
}
|
|
}
|
|
tag.frames.push(frame);
|
|
|
|
frameStart += 10; // advance past the frame header
|
|
frameStart += frameSize; // advance past the frame body
|
|
} while (frameStart < tagSize);
|
|
this.trigger('data', tag);
|
|
};
|
|
};
|
|
MetadataStream.prototype = new Stream();
|
|
|
|
module.exports = MetadataStream;
|
|
|
|
},{"../utils/stream":55,"./stream-types":48}],48:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = {
|
|
H264_STREAM_TYPE: 0x1B,
|
|
ADTS_STREAM_TYPE: 0x0F,
|
|
METADATA_STREAM_TYPE: 0x15
|
|
};
|
|
|
|
},{}],49:[function(require,module,exports){
|
|
module.exports = {
|
|
generator: require('./mp4-generator'),
|
|
Transmuxer: require('./transmuxer').Transmuxer,
|
|
AudioSegmentStream: require('./transmuxer').AudioSegmentStream,
|
|
VideoSegmentStream: require('./transmuxer').VideoSegmentStream,
|
|
tools: require('../tools/mp4-inspector'),
|
|
};
|
|
|
|
},{"../tools/mp4-inspector":53,"./mp4-generator":50,"./transmuxer":51}],50:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2015 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* Functions that generate fragmented MP4s suitable for use with Media
|
|
* Source Extensions.
|
|
*/
|
|
'use strict';
|
|
|
|
var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak,
|
|
tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, styp, traf, trex, trun,
|
|
types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR,
|
|
AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS;
|
|
|
|
// pre-calculate constants
|
|
(function() {
|
|
var i;
|
|
types = {
|
|
avc1: [], // codingname
|
|
avcC: [],
|
|
btrt: [],
|
|
dinf: [],
|
|
dref: [],
|
|
esds: [],
|
|
ftyp: [],
|
|
hdlr: [],
|
|
mdat: [],
|
|
mdhd: [],
|
|
mdia: [],
|
|
mfhd: [],
|
|
minf: [],
|
|
moof: [],
|
|
moov: [],
|
|
mp4a: [], // codingname
|
|
mvex: [],
|
|
mvhd: [],
|
|
sdtp: [],
|
|
smhd: [],
|
|
stbl: [],
|
|
stco: [],
|
|
stsc: [],
|
|
stsd: [],
|
|
stsz: [],
|
|
stts: [],
|
|
styp: [],
|
|
tfdt: [],
|
|
tfhd: [],
|
|
traf: [],
|
|
trak: [],
|
|
trun: [],
|
|
trex: [],
|
|
tkhd: [],
|
|
vmhd: []
|
|
};
|
|
|
|
// In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we
|
|
// don't throw an error
|
|
if (typeof Uint8Array === 'undefined') {
|
|
return;
|
|
}
|
|
|
|
for (i in types) {
|
|
if (types.hasOwnProperty(i)) {
|
|
types[i] = [
|
|
i.charCodeAt(0),
|
|
i.charCodeAt(1),
|
|
i.charCodeAt(2),
|
|
i.charCodeAt(3)
|
|
];
|
|
}
|
|
}
|
|
|
|
MAJOR_BRAND = new Uint8Array([
|
|
'i'.charCodeAt(0),
|
|
's'.charCodeAt(0),
|
|
'o'.charCodeAt(0),
|
|
'm'.charCodeAt(0)
|
|
]);
|
|
AVC1_BRAND = new Uint8Array([
|
|
'a'.charCodeAt(0),
|
|
'v'.charCodeAt(0),
|
|
'c'.charCodeAt(0),
|
|
'1'.charCodeAt(0)
|
|
]);
|
|
MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);
|
|
VIDEO_HDLR = 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'
|
|
]);
|
|
AUDIO_HDLR = 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'
|
|
]);
|
|
HDLR_TYPES = {
|
|
"video":VIDEO_HDLR,
|
|
"audio": AUDIO_HDLR
|
|
};
|
|
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
|
|
]);
|
|
SMHD = new Uint8Array([
|
|
0x00, // version
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, // balance, 0 means centered
|
|
0x00, 0x00 // reserved
|
|
]);
|
|
STCO = new Uint8Array([
|
|
0x00, // version
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, 0x00, 0x00 // entry_count
|
|
]);
|
|
STSC = STCO;
|
|
STSZ = new Uint8Array([
|
|
0x00, // version
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, 0x00, 0x00, // sample_size
|
|
0x00, 0x00, 0x00, 0x00, // sample_count
|
|
]);
|
|
STTS = STCO;
|
|
VMHD = new Uint8Array([
|
|
0x00, // version
|
|
0x00, 0x00, 0x01, // flags
|
|
0x00, 0x00, // graphicsmode
|
|
0x00, 0x00,
|
|
0x00, 0x00,
|
|
0x00, 0x00 // opcolor
|
|
]);
|
|
})();
|
|
|
|
box = function(type) {
|
|
var
|
|
payload = [],
|
|
size = 0,
|
|
i,
|
|
result,
|
|
view;
|
|
|
|
for (i = 1; i < arguments.length; i++) {
|
|
payload.push(arguments[i]);
|
|
}
|
|
|
|
i = payload.length;
|
|
|
|
// calculate the total size we need to allocate
|
|
while (i--) {
|
|
size += payload[i].byteLength;
|
|
}
|
|
result = new Uint8Array(size + 8);
|
|
view = new DataView(result.buffer, result.byteOffset, result.byteLength);
|
|
view.setUint32(0, result.byteLength);
|
|
result.set(type, 4);
|
|
|
|
// copy the payload into the result
|
|
for (i = 0, size = 8; i < payload.length; i++) {
|
|
result.set(payload[i], size);
|
|
size += payload[i].byteLength;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
dinf = function() {
|
|
return box(types.dinf, box(types.dref, DREF));
|
|
};
|
|
|
|
esds = function(track) {
|
|
return box(types.esds, new Uint8Array([
|
|
0x00, // version
|
|
0x00, 0x00, 0x00, // flags
|
|
|
|
// ES_Descriptor
|
|
0x03, // tag, ES_DescrTag
|
|
0x19, // length
|
|
0x00, 0x00, // ES_ID
|
|
0x00, // streamDependenceFlag, URL_flag, reserved, streamPriority
|
|
|
|
// DecoderConfigDescriptor
|
|
0x04, // tag, DecoderConfigDescrTag
|
|
0x11, // length
|
|
0x40, // object type
|
|
0x15, // streamType
|
|
0x00, 0x06, 0x00, // bufferSizeDB
|
|
0x00, 0x00, 0xda, 0xc0, // maxBitrate
|
|
0x00, 0x00, 0xda, 0xc0, // avgBitrate
|
|
|
|
// DecoderSpecificInfo
|
|
0x05, // tag, DecoderSpecificInfoTag
|
|
0x02, // length
|
|
// ISO/IEC 14496-3, AudioSpecificConfig
|
|
// for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35
|
|
(track.audioobjecttype << 3) | (track.samplingfrequencyindex >>> 1),
|
|
(track.samplingfrequencyindex << 7) | (track.channelcount << 3),
|
|
0x06, 0x01, 0x02 // GASpecificConfig
|
|
]));
|
|
};
|
|
|
|
ftyp = function() {
|
|
return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);
|
|
};
|
|
|
|
hdlr = function(type) {
|
|
return box(types.hdlr, HDLR_TYPES[type]);
|
|
};
|
|
mdat = function(data) {
|
|
return box(types.mdat, data);
|
|
};
|
|
mdhd = function(track) {
|
|
var result = new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, 0x00, 0x02, // creation_time
|
|
0x00, 0x00, 0x00, 0x03, // modification_time
|
|
0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 "ticks" per second
|
|
|
|
(track.duration >>> 24) & 0xFF,
|
|
(track.duration >>> 16) & 0xFF,
|
|
(track.duration >>> 8) & 0xFF,
|
|
track.duration & 0xFF, // duration
|
|
0x55, 0xc4, // 'und' language (undetermined)
|
|
0x00, 0x00
|
|
]);
|
|
|
|
// Use the sample rate from the track metadata, when it is
|
|
// defined. The sample rate can be parsed out of an ADTS header, for
|
|
// instance.
|
|
if (track.samplerate) {
|
|
result[12] = (track.samplerate >>> 24) & 0xFF;
|
|
result[13] = (track.samplerate >>> 16) & 0xFF;
|
|
result[14] = (track.samplerate >>> 8) & 0xFF;
|
|
result[15] = (track.samplerate) & 0xFF;
|
|
}
|
|
|
|
return box(types.mdhd, result);
|
|
};
|
|
mdia = function(track) {
|
|
return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));
|
|
};
|
|
mfhd = function(sequenceNumber) {
|
|
return box(types.mfhd, new Uint8Array([
|
|
0x00,
|
|
0x00, 0x00, 0x00, // flags
|
|
(sequenceNumber & 0xFF000000) >> 24,
|
|
(sequenceNumber & 0xFF0000) >> 16,
|
|
(sequenceNumber & 0xFF00) >> 8,
|
|
sequenceNumber & 0xFF, // sequence_number
|
|
]));
|
|
};
|
|
minf = function(track) {
|
|
return box(types.minf,
|
|
track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD),
|
|
dinf(),
|
|
stbl(track));
|
|
};
|
|
moof = function(sequenceNumber, tracks) {
|
|
var
|
|
trackFragments = [],
|
|
i = tracks.length;
|
|
// build traf boxes for each track fragment
|
|
while (i--) {
|
|
trackFragments[i] = traf(tracks[i]);
|
|
}
|
|
return box.apply(null, [
|
|
types.moof,
|
|
mfhd(sequenceNumber)
|
|
].concat(trackFragments));
|
|
};
|
|
/**
|
|
* Returns a movie box.
|
|
* @param tracks {array} the tracks associated with this movie
|
|
* @see ISO/IEC 14496-12:2012(E), section 8.2.1
|
|
*/
|
|
moov = function(tracks) {
|
|
var
|
|
i = tracks.length,
|
|
boxes = [];
|
|
|
|
while (i--) {
|
|
boxes[i] = trak(tracks[i]);
|
|
}
|
|
|
|
return box.apply(null, [types.moov, mvhd(0xffffffff)].concat(boxes).concat(mvex(tracks)));
|
|
};
|
|
mvex = function(tracks) {
|
|
var
|
|
i = tracks.length,
|
|
boxes = [];
|
|
|
|
while (i--) {
|
|
boxes[i] = trex(tracks[i]);
|
|
}
|
|
return box.apply(null, [types.mvex].concat(boxes));
|
|
};
|
|
mvhd = function(duration) {
|
|
var
|
|
bytes = new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, 0x00, 0x01, // creation_time
|
|
0x00, 0x00, 0x00, 0x02, // modification_time
|
|
0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 "ticks" per second
|
|
(duration & 0xFF000000) >> 24,
|
|
(duration & 0xFF0000) >> 16,
|
|
(duration & 0xFF00) >> 8,
|
|
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 box(types.mvhd, bytes);
|
|
};
|
|
|
|
sdtp = function(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 box(types.sdtp,
|
|
bytes);
|
|
};
|
|
|
|
stbl = function(track) {
|
|
return box(types.stbl,
|
|
stsd(track),
|
|
box(types.stts, STTS),
|
|
box(types.stsc, STSC),
|
|
box(types.stsz, STSZ),
|
|
box(types.stco, STCO));
|
|
};
|
|
|
|
(function() {
|
|
var videoSample, audioSample;
|
|
|
|
stsd = function(track) {
|
|
|
|
return box(types.stsd, new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x00, // flags
|
|
0x00, 0x00, 0x00, 0x01
|
|
]), track.type === 'video' ? videoSample(track) : audioSample(track));
|
|
};
|
|
|
|
videoSample = function(track) {
|
|
var
|
|
sps = track.sps || [],
|
|
pps = track.pps || [],
|
|
sequenceParameterSets = [],
|
|
pictureParameterSets = [],
|
|
i;
|
|
|
|
// assemble the SPSs
|
|
for (i = 0; i < sps.length; i++) {
|
|
sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);
|
|
sequenceParameterSets.push((sps[i].byteLength & 0xFF)); // sequenceParameterSetLength
|
|
sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS
|
|
}
|
|
|
|
// assemble the PPSs
|
|
for (i = 0; i < pps.length; i++) {
|
|
pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);
|
|
pictureParameterSets.push((pps[i].byteLength & 0xFF));
|
|
pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));
|
|
}
|
|
|
|
return box(types.avc1, new Uint8Array([
|
|
0x00, 0x00, 0x00,
|
|
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
|
|
(track.width & 0xff00) >> 8,
|
|
track.width & 0xff, // width
|
|
(track.height & 0xff00) >> 8,
|
|
track.height & 0xff, // height
|
|
0x00, 0x48, 0x00, 0x00, // horizresolution
|
|
0x00, 0x48, 0x00, 0x00, // vertresolution
|
|
0x00, 0x00, 0x00, 0x00, // reserved
|
|
0x00, 0x01, // frame_count
|
|
0x13,
|
|
0x76, 0x69, 0x64, 0x65,
|
|
0x6f, 0x6a, 0x73, 0x2d,
|
|
0x63, 0x6f, 0x6e, 0x74,
|
|
0x72, 0x69, 0x62, 0x2d,
|
|
0x68, 0x6c, 0x73, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, // compressorname
|
|
0x00, 0x18, // depth = 24
|
|
0x11, 0x11 // pre_defined = -1
|
|
]), box(types.avcC, new Uint8Array([
|
|
0x01, // configurationVersion
|
|
track.profileIdc, // AVCProfileIndication
|
|
track.profileCompatibility, // profile_compatibility
|
|
track.levelIdc, // AVCLevelIndication
|
|
0xff // lengthSizeMinusOne, hard-coded to 4 bytes
|
|
].concat([
|
|
sps.length // numOfSequenceParameterSets
|
|
]).concat(sequenceParameterSets).concat([
|
|
pps.length // numOfPictureParameterSets
|
|
]).concat(pictureParameterSets))), // "PPS"
|
|
box(types.btrt, new Uint8Array([
|
|
0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB
|
|
0x00, 0x2d, 0xc6, 0xc0, // maxBitrate
|
|
0x00, 0x2d, 0xc6, 0xc0
|
|
])) // avgBitrate
|
|
);
|
|
};
|
|
|
|
audioSample = function(track) {
|
|
return box(types.mp4a, new Uint8Array([
|
|
|
|
// SampleEntry, ISO/IEC 14496-12
|
|
0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, // reserved
|
|
0x00, 0x01, // data_reference_index
|
|
|
|
// AudioSampleEntry, ISO/IEC 14496-12
|
|
0x00, 0x00, 0x00, 0x00, // reserved
|
|
0x00, 0x00, 0x00, 0x00, // reserved
|
|
(track.channelcount & 0xff00) >> 8,
|
|
(track.channelcount & 0xff), // channelcount
|
|
|
|
(track.samplesize & 0xff00) >> 8,
|
|
(track.samplesize & 0xff), // samplesize
|
|
0x00, 0x00, // pre_defined
|
|
0x00, 0x00, // reserved
|
|
|
|
(track.samplerate & 0xff00) >> 8,
|
|
(track.samplerate & 0xff),
|
|
0x00, 0x00 // samplerate, 16.16
|
|
|
|
// MP4AudioSampleEntry, ISO/IEC 14496-14
|
|
]), esds(track));
|
|
};
|
|
})();
|
|
|
|
styp = function() {
|
|
return box(types.styp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND);
|
|
};
|
|
|
|
tkhd = function(track) {
|
|
var result = new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x07, // flags
|
|
0x00, 0x00, 0x00, 0x00, // creation_time
|
|
0x00, 0x00, 0x00, 0x00, // modification_time
|
|
(track.id & 0xFF000000) >> 24,
|
|
(track.id & 0xFF0000) >> 16,
|
|
(track.id & 0xFF00) >> 8,
|
|
track.id & 0xFF, // track_ID
|
|
0x00, 0x00, 0x00, 0x00, // reserved
|
|
(track.duration & 0xFF000000) >> 24,
|
|
(track.duration & 0xFF0000) >> 16,
|
|
(track.duration & 0xFF00) >> 8,
|
|
track.duration & 0xFF, // duration
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, // reserved
|
|
0x00, 0x00, // layer
|
|
0x00, 0x00, // alternate_group
|
|
0x01, 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
|
|
(track.width & 0xFF00) >> 8,
|
|
track.width & 0xFF,
|
|
0x00, 0x00, // width
|
|
(track.height & 0xFF00) >> 8,
|
|
track.height & 0xFF,
|
|
0x00, 0x00 // height
|
|
]);
|
|
|
|
return box(types.tkhd, result);
|
|
};
|
|
|
|
/**
|
|
* Generate a track fragment (traf) box. A traf box collects metadata
|
|
* about tracks in a movie fragment (moof) box.
|
|
*/
|
|
traf = function(track) {
|
|
var trackFragmentHeader, trackFragmentDecodeTime,
|
|
trackFragmentRun, sampleDependencyTable, dataOffset;
|
|
|
|
trackFragmentHeader = box(types.tfhd, new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x3a, // flags
|
|
(track.id & 0xFF000000) >> 24,
|
|
(track.id & 0xFF0000) >> 16,
|
|
(track.id & 0xFF00) >> 8,
|
|
(track.id & 0xFF), // track_ID
|
|
0x00, 0x00, 0x00, 0x01, // sample_description_index
|
|
0x00, 0x00, 0x00, 0x00, // default_sample_duration
|
|
0x00, 0x00, 0x00, 0x00, // default_sample_size
|
|
0x00, 0x00, 0x00, 0x00 // default_sample_flags
|
|
]));
|
|
|
|
trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x00, // flags
|
|
// baseMediaDecodeTime
|
|
(track.baseMediaDecodeTime >>> 24) & 0xFF,
|
|
(track.baseMediaDecodeTime >>> 16) & 0xFF,
|
|
(track.baseMediaDecodeTime >>> 8) & 0xFF,
|
|
track.baseMediaDecodeTime & 0xFF
|
|
]));
|
|
|
|
// the data offset specifies the number of bytes from the start of
|
|
// the containing moof to the first payload byte of the associated
|
|
// mdat
|
|
dataOffset = (32 + // tfhd
|
|
16 + // tfdt
|
|
8 + // traf header
|
|
16 + // mfhd
|
|
8 + // moof header
|
|
8); // mdat header
|
|
|
|
// audio tracks require less metadata
|
|
if (track.type === 'audio') {
|
|
trackFragmentRun = trun(track, dataOffset);
|
|
return box(types.traf,
|
|
trackFragmentHeader,
|
|
trackFragmentDecodeTime,
|
|
trackFragmentRun);
|
|
}
|
|
|
|
// video tracks should contain an independent and disposable samples
|
|
// box (sdtp)
|
|
// generate one and adjust offsets to match
|
|
sampleDependencyTable = sdtp(track);
|
|
trackFragmentRun = trun(track,
|
|
sampleDependencyTable.length + dataOffset);
|
|
return box(types.traf,
|
|
trackFragmentHeader,
|
|
trackFragmentDecodeTime,
|
|
trackFragmentRun,
|
|
sampleDependencyTable);
|
|
};
|
|
|
|
/**
|
|
* Generate a track box.
|
|
* @param track {object} a track definition
|
|
* @return {Uint8Array} the track box
|
|
*/
|
|
trak = function(track) {
|
|
track.duration = track.duration || 0xffffffff;
|
|
return box(types.trak,
|
|
tkhd(track),
|
|
mdia(track));
|
|
};
|
|
|
|
trex = function(track) {
|
|
var result = new Uint8Array([
|
|
0x00, // version 0
|
|
0x00, 0x00, 0x00, // flags
|
|
(track.id & 0xFF000000) >> 24,
|
|
(track.id & 0xFF0000) >> 16,
|
|
(track.id & 0xFF00) >> 8,
|
|
(track.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
|
|
]);
|
|
// the last two bytes of default_sample_flags is the sample
|
|
// degradation priority, a hint about the importance of this sample
|
|
// relative to others. Lower the degradation priority for all sample
|
|
// types other than video.
|
|
if (track.type !== 'video') {
|
|
result[result.length - 1] = 0x00;
|
|
}
|
|
|
|
return box(types.trex, result);
|
|
};
|
|
|
|
(function() {
|
|
var audioTrun, videoTrun, trunHeader;
|
|
|
|
// This method assumes all samples are uniform. That is, if a
|
|
// duration is present for the first sample, it will be present for
|
|
// all subsequent samples.
|
|
// see ISO/IEC 14496-12:2012, Section 8.8.8.1
|
|
trunHeader = function(samples, offset) {
|
|
var durationPresent = 0, sizePresent = 0,
|
|
flagsPresent = 0, compositionTimeOffset = 0;
|
|
|
|
// trun flag constants
|
|
if (samples.length) {
|
|
if (samples[0].duration !== undefined) {
|
|
durationPresent = 0x1;
|
|
}
|
|
if (samples[0].size !== undefined) {
|
|
sizePresent = 0x2;
|
|
}
|
|
if (samples[0].flags !== undefined) {
|
|
flagsPresent = 0x4;
|
|
}
|
|
if (samples[0].compositionTimeOffset !== undefined) {
|
|
compositionTimeOffset = 0x8;
|
|
}
|
|
}
|
|
|
|
return [
|
|
0x00, // version 0
|
|
0x00,
|
|
durationPresent | sizePresent | flagsPresent | compositionTimeOffset,
|
|
0x01, // flags
|
|
(samples.length & 0xFF000000) >>> 24,
|
|
(samples.length & 0xFF0000) >>> 16,
|
|
(samples.length & 0xFF00) >>> 8,
|
|
samples.length & 0xFF, // sample_count
|
|
(offset & 0xFF000000) >>> 24,
|
|
(offset & 0xFF0000) >>> 16,
|
|
(offset & 0xFF00) >>> 8,
|
|
offset & 0xFF // data_offset
|
|
];
|
|
};
|
|
|
|
videoTrun = function(track, offset) {
|
|
var bytes, samples, sample, i;
|
|
|
|
samples = track.samples || [];
|
|
offset += 8 + 12 + (16 * samples.length);
|
|
|
|
bytes = trunHeader(samples, offset);
|
|
|
|
for (i = 0; i < samples.length; i++) {
|
|
sample = samples[i];
|
|
bytes = bytes.concat([
|
|
(sample.duration & 0xFF000000) >>> 24,
|
|
(sample.duration & 0xFF0000) >>> 16,
|
|
(sample.duration & 0xFF00) >>> 8,
|
|
sample.duration & 0xFF, // sample_duration
|
|
(sample.size & 0xFF000000) >>> 24,
|
|
(sample.size & 0xFF0000) >>> 16,
|
|
(sample.size & 0xFF00) >>> 8,
|
|
sample.size & 0xFF, // sample_size
|
|
(sample.flags.isLeading << 2) | sample.flags.dependsOn,
|
|
(sample.flags.isDependedOn << 6) |
|
|
(sample.flags.hasRedundancy << 4) |
|
|
(sample.flags.paddingValue << 1) |
|
|
sample.flags.isNonSyncSample,
|
|
sample.flags.degradationPriority & 0xF0 << 8,
|
|
sample.flags.degradationPriority & 0x0F, // sample_flags
|
|
(sample.compositionTimeOffset & 0xFF000000) >>> 24,
|
|
(sample.compositionTimeOffset & 0xFF0000) >>> 16,
|
|
(sample.compositionTimeOffset & 0xFF00) >>> 8,
|
|
sample.compositionTimeOffset & 0xFF // sample_composition_time_offset
|
|
]);
|
|
}
|
|
return box(types.trun, new Uint8Array(bytes));
|
|
};
|
|
|
|
audioTrun = function(track, offset) {
|
|
var bytes, samples, sample, i;
|
|
|
|
samples = track.samples || [];
|
|
offset += 8 + 12 + (8 * samples.length);
|
|
|
|
bytes = trunHeader(samples, offset);
|
|
|
|
for (i = 0; i < samples.length; i++) {
|
|
sample = samples[i];
|
|
bytes = bytes.concat([
|
|
(sample.duration & 0xFF000000) >>> 24,
|
|
(sample.duration & 0xFF0000) >>> 16,
|
|
(sample.duration & 0xFF00) >>> 8,
|
|
sample.duration & 0xFF, // sample_duration
|
|
(sample.size & 0xFF000000) >>> 24,
|
|
(sample.size & 0xFF0000) >>> 16,
|
|
(sample.size & 0xFF00) >>> 8,
|
|
sample.size & 0xFF]); // sample_size
|
|
}
|
|
|
|
return box(types.trun, new Uint8Array(bytes));
|
|
};
|
|
|
|
trun = function(track, offset) {
|
|
if (track.type === 'audio') {
|
|
return audioTrun(track, offset);
|
|
} else {
|
|
return videoTrun(track, offset);
|
|
}
|
|
};
|
|
})();
|
|
|
|
module.exports = {
|
|
ftyp: ftyp,
|
|
mdat: mdat,
|
|
moof: moof,
|
|
moov: moov,
|
|
initSegment: function(tracks) {
|
|
var
|
|
fileType = ftyp(),
|
|
movie = moov(tracks),
|
|
result;
|
|
|
|
result = new Uint8Array(fileType.byteLength + movie.byteLength);
|
|
result.set(fileType);
|
|
result.set(movie, fileType.byteLength);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
},{}],51:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2015 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* A stream-based mp2t to mp4 converter. This utility can be used to
|
|
* deliver mp4s to a SourceBuffer on platforms that support native
|
|
* Media Source Extensions.
|
|
*/
|
|
'use strict';
|
|
|
|
var Stream = require('../utils/stream.js');
|
|
var mp4 = require('./mp4-generator.js');
|
|
var m2ts = require('../m2ts/m2ts.js');
|
|
var AdtsStream = require('../codecs/adts.js');
|
|
var H264Stream = require('../codecs/h264').H264Stream;
|
|
var AacStream = require('../aac');
|
|
|
|
// constants
|
|
var AUDIO_PROPERTIES = [
|
|
'audioobjecttype',
|
|
'channelcount',
|
|
'samplerate',
|
|
'samplingfrequencyindex',
|
|
'samplesize'
|
|
];
|
|
|
|
var VIDEO_PROPERTIES = [
|
|
'width',
|
|
'height',
|
|
'profileIdc',
|
|
'levelIdc',
|
|
'profileCompatibility',
|
|
];
|
|
|
|
// object types
|
|
var VideoSegmentStream, AudioSegmentStream, Transmuxer, CoalesceStream;
|
|
|
|
// Helper functions
|
|
var
|
|
createDefaultSample,
|
|
isLikelyAacData,
|
|
collectDtsInfo,
|
|
clearDtsInfo,
|
|
calculateTrackBaseMediaDecodeTime,
|
|
arrayEquals,
|
|
sumFrameByteLengths;
|
|
|
|
/**
|
|
* Default sample object
|
|
* see ISO/IEC 14496-12:2012, section 8.6.4.3
|
|
*/
|
|
createDefaultSample = function () {
|
|
return {
|
|
size: 0,
|
|
flags: {
|
|
isLeading: 0,
|
|
dependsOn: 1,
|
|
isDependedOn: 0,
|
|
hasRedundancy: 0,
|
|
degradationPriority: 0
|
|
}
|
|
};
|
|
};
|
|
|
|
isLikelyAacData = function (data) {
|
|
if ((data[0] === 'I'.charCodeAt(0)) &&
|
|
(data[1] === 'D'.charCodeAt(0)) &&
|
|
(data[2] === '3'.charCodeAt(0))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Compare two arrays (even typed) for same-ness
|
|
*/
|
|
arrayEquals = function(a, b) {
|
|
var
|
|
i;
|
|
|
|
if (a.length !== b.length) {
|
|
return false;
|
|
}
|
|
|
|
// compare the value of each element in the array
|
|
for (i = 0; i < a.length; i++) {
|
|
if (a[i] !== b[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Sum the `byteLength` properties of the data in each AAC frame
|
|
*/
|
|
sumFrameByteLengths = function(array) {
|
|
var
|
|
i,
|
|
currentObj,
|
|
sum = 0;
|
|
|
|
// sum the byteLength's all each nal unit in the frame
|
|
for (i = 0; i < array.length; i++) {
|
|
currentObj = array[i];
|
|
sum += currentObj.data.byteLength;
|
|
}
|
|
|
|
return sum;
|
|
};
|
|
|
|
/**
|
|
* Constructs a single-track, ISO BMFF media segment from AAC data
|
|
* events. The output of this stream can be fed to a SourceBuffer
|
|
* configured with a suitable initialization segment.
|
|
*/
|
|
AudioSegmentStream = function(track) {
|
|
var
|
|
adtsFrames = [],
|
|
sequenceNumber = 0,
|
|
earliestAllowedDts = 0;
|
|
|
|
AudioSegmentStream.prototype.init.call(this);
|
|
|
|
this.push = function(data) {
|
|
collectDtsInfo(track, data);
|
|
|
|
if (track) {
|
|
AUDIO_PROPERTIES.forEach(function(prop) {
|
|
track[prop] = data[prop];
|
|
});
|
|
}
|
|
|
|
// buffer audio data until end() is called
|
|
adtsFrames.push(data);
|
|
};
|
|
|
|
this.setEarliestDts = function(earliestDts) {
|
|
earliestAllowedDts = earliestDts - track.timelineStartInfo.baseMediaDecodeTime;
|
|
};
|
|
|
|
this.flush = function() {
|
|
var
|
|
frames,
|
|
moof,
|
|
mdat,
|
|
boxes;
|
|
|
|
// return early if no audio data has been observed
|
|
if (adtsFrames.length === 0) {
|
|
this.trigger('done', 'AudioSegmentStream');
|
|
return;
|
|
}
|
|
|
|
frames = this.trimAdtsFramesByEarliestDts_(adtsFrames);
|
|
|
|
// we have to build the index from byte locations to
|
|
// samples (that is, adts frames) in the audio data
|
|
track.samples = this.generateSampleTable_(frames);
|
|
|
|
// concatenate the audio data to constuct the mdat
|
|
mdat = mp4.mdat(this.concatenateFrameData_(frames));
|
|
|
|
adtsFrames = [];
|
|
|
|
calculateTrackBaseMediaDecodeTime(track);
|
|
moof = mp4.moof(sequenceNumber, [track]);
|
|
boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
|
|
|
|
// bump the sequence number for next time
|
|
sequenceNumber++;
|
|
|
|
boxes.set(moof);
|
|
boxes.set(mdat, moof.byteLength);
|
|
|
|
clearDtsInfo(track);
|
|
|
|
this.trigger('data', {track: track, boxes: boxes});
|
|
this.trigger('done', 'AudioSegmentStream');
|
|
};
|
|
|
|
// If the audio segment extends before the earliest allowed dts
|
|
// value, remove AAC frames until starts at or after the earliest
|
|
// allowed DTS so that we don't end up with a negative baseMedia-
|
|
// DecodeTime for the audio track
|
|
this.trimAdtsFramesByEarliestDts_ = function(adtsFrames) {
|
|
if (track.minSegmentDts >= earliestAllowedDts) {
|
|
return adtsFrames;
|
|
}
|
|
|
|
// We will need to recalculate the earliest segment Dts
|
|
track.minSegmentDts = Infinity;
|
|
|
|
return adtsFrames.filter(function(currentFrame) {
|
|
// If this is an allowed frame, keep it and record it's Dts
|
|
if (currentFrame.dts >= earliestAllowedDts) {
|
|
track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);
|
|
track.minSegmentPts = track.minSegmentDts;
|
|
return true;
|
|
}
|
|
// Otherwise, discard it
|
|
return false;
|
|
});
|
|
};
|
|
|
|
// generate the track's raw mdat data from an array of frames
|
|
this.generateSampleTable_ = function(frames) {
|
|
var
|
|
i,
|
|
currentFrame,
|
|
samples = [];
|
|
|
|
for (i = 0; i < frames.length; i++) {
|
|
currentFrame = frames[i];
|
|
samples.push({
|
|
size: currentFrame.data.byteLength,
|
|
duration: 1024 // For AAC audio, all samples contain 1024 samples
|
|
});
|
|
}
|
|
return samples;
|
|
};
|
|
|
|
// generate the track's sample table from an array of frames
|
|
this.concatenateFrameData_ = function(frames) {
|
|
var
|
|
i,
|
|
currentFrame,
|
|
dataOffset = 0,
|
|
data = new Uint8Array(sumFrameByteLengths(frames));
|
|
|
|
for (i = 0; i < frames.length; i++) {
|
|
currentFrame = frames[i];
|
|
|
|
data.set(currentFrame.data, dataOffset);
|
|
dataOffset += currentFrame.data.byteLength;
|
|
}
|
|
return data;
|
|
};
|
|
};
|
|
|
|
AudioSegmentStream.prototype = new Stream();
|
|
|
|
/**
|
|
* Constructs a single-track, ISO BMFF media segment from H264 data
|
|
* events. The output of this stream can be fed to a SourceBuffer
|
|
* configured with a suitable initialization segment.
|
|
* @param track {object} track metadata configuration
|
|
*/
|
|
VideoSegmentStream = function(track) {
|
|
var
|
|
sequenceNumber = 0,
|
|
nalUnits = [],
|
|
config,
|
|
pps;
|
|
|
|
VideoSegmentStream.prototype.init.call(this);
|
|
|
|
delete track.minPTS;
|
|
|
|
this.gopCache_ = [];
|
|
|
|
this.push = function(nalUnit) {
|
|
collectDtsInfo(track, nalUnit);
|
|
|
|
// record the track config
|
|
if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {
|
|
config = nalUnit.config;
|
|
track.sps = [nalUnit.data];
|
|
|
|
VIDEO_PROPERTIES.forEach(function(prop) {
|
|
track[prop] = config[prop];
|
|
}, this);
|
|
}
|
|
|
|
if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' &&
|
|
!pps) {
|
|
pps = nalUnit.data;
|
|
track.pps = [nalUnit.data];
|
|
}
|
|
|
|
// buffer video until flush() is called
|
|
nalUnits.push(nalUnit);
|
|
};
|
|
|
|
this.flush = function() {
|
|
var
|
|
frames,
|
|
gopForFusion,
|
|
gops,
|
|
moof,
|
|
mdat,
|
|
boxes;
|
|
|
|
// Throw away nalUnits at the start of the byte stream until
|
|
// we find the first AUD
|
|
while (nalUnits.length) {
|
|
if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {
|
|
break;
|
|
}
|
|
nalUnits.shift();
|
|
}
|
|
|
|
// Return early if no video data has been observed
|
|
if (nalUnits.length === 0) {
|
|
this.resetStream_();
|
|
this.trigger('done', 'VideoSegmentStream');
|
|
return;
|
|
}
|
|
|
|
// Organize the raw nal-units into arrays that represent
|
|
// higher-level constructs such as frames and gops
|
|
// (group-of-pictures)
|
|
frames = this.groupNalsIntoFrames_(nalUnits);
|
|
gops = this.groupFramesIntoGops_(frames);
|
|
|
|
// If the first frame of this fragment is not a keyframe we have
|
|
// a problem since MSE (on Chrome) requires a leading keyframe.
|
|
//
|
|
// We have two approaches to repairing this situation:
|
|
// 1) GOP-FUSION:
|
|
// This is where we keep track of the GOPS (group-of-pictures)
|
|
// from previous fragments and attempt to find one that we can
|
|
// prepend to the current fragment in order to create a valid
|
|
// fragment.
|
|
// 2) KEYFRAME-PULLING:
|
|
// Here we search for the first keyframe in the fragment and
|
|
// throw away all the frames between the start of the fragment
|
|
// and that keyframe. We then extend the duration and pull the
|
|
// PTS of the keyframe forward so that it covers the time range
|
|
// of the frames that were disposed of.
|
|
//
|
|
// #1 is far prefereable over #2 which can cause "stuttering" but
|
|
// requires more things to be just right.
|
|
if (!gops[0][0].keyFrame) {
|
|
// Search for a gop for fusion from our gopCache
|
|
gopForFusion = this.getGopForFusion_(nalUnits[0], track);
|
|
|
|
if (gopForFusion) {
|
|
gops.unshift(gopForFusion);
|
|
// Adjust Gops' metadata to account for the inclusion of the
|
|
// new gop at the beginning
|
|
gops.byteLength += gopForFusion.byteLength;
|
|
gops.nalCount += gopForFusion.nalCount;
|
|
gops.pts = gopForFusion.pts;
|
|
gops.dts = gopForFusion.dts;
|
|
gops.duration += gopForFusion.duration;
|
|
} else {
|
|
// If we didn't find a candidate gop fall back to keyrame-pulling
|
|
gops = this.extendFirstKeyFrame_(gops);
|
|
}
|
|
}
|
|
collectDtsInfo(track, gops);
|
|
|
|
// First, we have to build the index from byte locations to
|
|
// samples (that is, frames) in the video data
|
|
track.samples = this.generateSampleTable_(gops);
|
|
|
|
// Concatenate the video data and construct the mdat
|
|
mdat = mp4.mdat(this.concatenateNalData_(gops));
|
|
|
|
// save all the nals in the last GOP into the gop cache
|
|
this.gopCache_.unshift({
|
|
gop: gops.pop(),
|
|
pps: track.pps,
|
|
sps: track.sps
|
|
});
|
|
|
|
// Keep a maximum of 6 GOPs in the cache
|
|
this.gopCache_.length = Math.min(6, this.gopCache_.length);
|
|
|
|
// Clear nalUnits
|
|
nalUnits = [];
|
|
|
|
calculateTrackBaseMediaDecodeTime(track);
|
|
|
|
this.trigger('timelineStartInfo', track.timelineStartInfo);
|
|
|
|
moof = mp4.moof(sequenceNumber, [track]);
|
|
|
|
// it would be great to allocate this array up front instead of
|
|
// throwing away hundreds of media segment fragments
|
|
boxes = new Uint8Array(moof.byteLength + mdat.byteLength);
|
|
|
|
// Bump the sequence number for next time
|
|
sequenceNumber++;
|
|
|
|
boxes.set(moof);
|
|
boxes.set(mdat, moof.byteLength);
|
|
|
|
this.trigger('data', {track: track, boxes: boxes});
|
|
|
|
this.resetStream_();
|
|
|
|
// Continue with the flush process now
|
|
this.trigger('done', 'VideoSegmentStream');
|
|
};
|
|
|
|
this.resetStream_ = function() {
|
|
clearDtsInfo(track);
|
|
|
|
// reset config and pps because they may differ across segments
|
|
// for instance, when we are rendition switching
|
|
config = undefined;
|
|
pps = undefined;
|
|
};
|
|
|
|
// Search for a candidate Gop for gop-fusion from the gop cache and
|
|
// return it or return null if no good candidate was found
|
|
this.getGopForFusion_ = function (nalUnit) {
|
|
var
|
|
halfSecond = 45000, // Half-a-second in a 90khz clock
|
|
allowableOverlap = 10000, // About 3 frames @ 30fps
|
|
nearestDistance = Infinity,
|
|
dtsDistance,
|
|
nearestGopObj,
|
|
currentGop,
|
|
currentGopObj,
|
|
i;
|
|
|
|
// Search for the GOP nearest to the beginning of this nal unit
|
|
for (i = 0; i < this.gopCache_.length; i++) {
|
|
currentGopObj = this.gopCache_[i];
|
|
currentGop = currentGopObj.gop;
|
|
|
|
// Reject Gops with different SPS or PPS
|
|
if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) ||
|
|
!(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {
|
|
continue;
|
|
}
|
|
|
|
// Reject Gops that would require a negative baseMediaDecodeTime
|
|
if (currentGop.dts < track.timelineStartInfo.dts) {
|
|
continue;
|
|
}
|
|
|
|
// The distance between the end of the gop and the start of the nalUnit
|
|
dtsDistance = (nalUnit.dts - currentGop.dts) - currentGop.duration;
|
|
|
|
// Only consider GOPS that start before the nal unit and end within
|
|
// a half-second of the nal unit
|
|
if (dtsDistance >= -allowableOverlap &&
|
|
dtsDistance <= halfSecond) {
|
|
|
|
// Always use the closest GOP we found if there is more than
|
|
// one candidate
|
|
if (!nearestGopObj ||
|
|
nearestDistance > dtsDistance) {
|
|
nearestGopObj = currentGopObj;
|
|
nearestDistance = dtsDistance;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nearestGopObj) {
|
|
return nearestGopObj.gop;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
this.extendFirstKeyFrame_ = function(gops) {
|
|
var
|
|
h, i,
|
|
currentGop,
|
|
newGops;
|
|
|
|
if (!gops[0][0].keyFrame) {
|
|
// Remove the first GOP
|
|
currentGop = gops.shift();
|
|
|
|
gops.byteLength -= currentGop.byteLength;
|
|
gops.nalCount -= currentGop.nalCount;
|
|
|
|
// Extend the first frame of what is now the
|
|
// first gop to cover the time period of the
|
|
// frames we just removed
|
|
gops[0][0].dts = currentGop.dts;
|
|
gops[0][0].pts = currentGop.pts;
|
|
gops[0][0].duration += currentGop.duration;
|
|
}
|
|
|
|
return gops;
|
|
};
|
|
|
|
// Convert an array of nal units into an array of frames with each frame being
|
|
// composed of the nal units that make up that frame
|
|
// Also keep track of cummulative data about the frame from the nal units such
|
|
// as the frame duration, starting pts, etc.
|
|
this.groupNalsIntoFrames_ = function(nalUnits) {
|
|
var
|
|
i,
|
|
currentNal,
|
|
startPts,
|
|
startDts,
|
|
currentFrame = [],
|
|
frames = [];
|
|
|
|
currentFrame.byteLength = 0;
|
|
|
|
for (i = 0; i < nalUnits.length; i++) {
|
|
currentNal = nalUnits[i];
|
|
|
|
// Split on 'aud'-type nal units
|
|
if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {
|
|
// Since the very first nal unit is expected to be an AUD
|
|
// only push to the frames array when currentFrame is not empty
|
|
if (currentFrame.length) {
|
|
currentFrame.duration = currentNal.dts - currentFrame.dts;
|
|
frames.push(currentFrame);
|
|
}
|
|
currentFrame = [currentNal];
|
|
currentFrame.byteLength = currentNal.data.byteLength;
|
|
currentFrame.pts = currentNal.pts;
|
|
currentFrame.dts = currentNal.dts;
|
|
} else {
|
|
// Specifically flag key frames for ease of use later
|
|
if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {
|
|
currentFrame.keyFrame = true;
|
|
}
|
|
currentFrame.duration = currentNal.dts - currentFrame.dts;
|
|
currentFrame.byteLength += currentNal.data.byteLength;
|
|
currentFrame.push(currentNal);
|
|
}
|
|
}
|
|
|
|
// For the last frame, use the duration of the previous frame if we
|
|
// have nothing better to go on
|
|
if (frames.length &&
|
|
(!currentFrame.duration ||
|
|
currentFrame.duration <= 0)) {
|
|
currentFrame.duration = frames[frames.length - 1].duration;
|
|
}
|
|
|
|
// Push the final frame
|
|
frames.push(currentFrame);
|
|
return frames;
|
|
};
|
|
|
|
// Convert an array of frames into an array of Gop with each Gop being composed
|
|
// of the frames that make up that Gop
|
|
// Also keep track of cummulative data about the Gop from the frames such as the
|
|
// Gop duration, starting pts, etc.
|
|
this.groupFramesIntoGops_ = function(frames) {
|
|
var
|
|
i,
|
|
currentFrame,
|
|
currentGop = [],
|
|
gops = [];
|
|
|
|
// We must pre-set some of the values on the Gop since we
|
|
// keep running totals of these values
|
|
currentGop.byteLength = 0;
|
|
currentGop.nalCount = 0;
|
|
currentGop.duration = 0;
|
|
currentGop.pts = frames[0].pts;
|
|
currentGop.dts = frames[0].dts;
|
|
|
|
// store some metadata about all the Gops
|
|
gops.byteLength = 0;
|
|
gops.nalCount = 0;
|
|
gops.duration = 0;
|
|
gops.pts = frames[0].pts;
|
|
gops.dts = frames[0].dts;
|
|
|
|
for (i = 0; i < frames.length; i++) {
|
|
currentFrame = frames[i];
|
|
|
|
if (currentFrame.keyFrame) {
|
|
// Since the very first frame is expected to be an keyframe
|
|
// only push to the gops array when currentGop is not empty
|
|
if (currentGop.length) {
|
|
gops.push(currentGop);
|
|
gops.byteLength += currentGop.byteLength;
|
|
gops.nalCount += currentGop.nalCount;
|
|
gops.duration += currentGop.duration;
|
|
}
|
|
|
|
currentGop = [currentFrame];
|
|
currentGop.nalCount = currentFrame.length;
|
|
currentGop.byteLength = currentFrame.byteLength;
|
|
currentGop.pts = currentFrame.pts;
|
|
currentGop.dts = currentFrame.dts;
|
|
currentGop.duration = currentFrame.duration;
|
|
} else {
|
|
currentGop.duration += currentFrame.duration;
|
|
currentGop.nalCount += currentFrame.length;
|
|
currentGop.byteLength += currentFrame.byteLength;
|
|
currentGop.push(currentFrame);
|
|
}
|
|
}
|
|
|
|
if (gops.length && currentGop.duration <= 0) {
|
|
currentGop.duration = gops[gops.length - 1].duration;
|
|
}
|
|
gops.byteLength += currentGop.byteLength;
|
|
gops.nalCount += currentGop.nalCount;
|
|
gops.duration += currentGop.duration;
|
|
|
|
// push the final Gop
|
|
gops.push(currentGop);
|
|
return gops;
|
|
};
|
|
|
|
// generate the track's sample table from an array of gops
|
|
this.generateSampleTable_ = function(gops, baseDataOffset) {
|
|
var
|
|
h, i,
|
|
sample,
|
|
currentGop,
|
|
currentFrame,
|
|
currentSample,
|
|
dataOffset = baseDataOffset || 0,
|
|
samples = [];
|
|
|
|
for (h = 0; h < gops.length; h++) {
|
|
currentGop = gops[h];
|
|
|
|
for (i = 0; i < currentGop.length; i++) {
|
|
currentFrame = currentGop[i];
|
|
|
|
sample = createDefaultSample();
|
|
|
|
sample.dataOffset = dataOffset;
|
|
sample.compositionTimeOffset = currentFrame.pts - currentFrame.dts;
|
|
sample.duration = currentFrame.duration;
|
|
sample.size = 4 * currentFrame.length; // Space for nal unit size
|
|
sample.size += currentFrame.byteLength;
|
|
|
|
if (currentFrame.keyFrame) {
|
|
sample.flags.dependsOn = 2;
|
|
}
|
|
|
|
dataOffset += sample.size;
|
|
|
|
samples.push(sample);
|
|
}
|
|
}
|
|
return samples;
|
|
};
|
|
|
|
// generate the track's raw mdat data from an array of gops
|
|
this.concatenateNalData_ = function (gops) {
|
|
var
|
|
h, i, j,
|
|
currentGop,
|
|
currentFrame,
|
|
currentNal,
|
|
dataOffset = 0,
|
|
nalsByteLength = gops.byteLength,
|
|
numberOfNals = gops.nalCount,
|
|
totalByteLength = nalsByteLength + 4 * numberOfNals,
|
|
data = new Uint8Array(totalByteLength),
|
|
view = new DataView(data.buffer);
|
|
|
|
// For each Gop..
|
|
for (h = 0; h < gops.length; h++) {
|
|
currentGop = gops[h];
|
|
|
|
// For each Frame..
|
|
for (i = 0; i < currentGop.length; i++) {
|
|
currentFrame = currentGop[i];
|
|
|
|
// For each NAL..
|
|
for (j = 0; j < currentFrame.length; j++) {
|
|
currentNal = currentFrame[j];
|
|
|
|
view.setUint32(dataOffset, currentNal.data.byteLength);
|
|
dataOffset += 4;
|
|
data.set(currentNal.data, dataOffset);
|
|
dataOffset += currentNal.data.byteLength;
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
};
|
|
};
|
|
|
|
VideoSegmentStream.prototype = new Stream();
|
|
|
|
/**
|
|
* Store information about the start and end of the track and the
|
|
* duration for each frame/sample we process in order to calculate
|
|
* the baseMediaDecodeTime
|
|
*/
|
|
collectDtsInfo = function (track, data) {
|
|
if (typeof data.pts === 'number') {
|
|
if (track.timelineStartInfo.pts === undefined) {
|
|
track.timelineStartInfo.pts = data.pts;
|
|
}
|
|
|
|
if (track.minSegmentPts === undefined) {
|
|
track.minSegmentPts = data.pts;
|
|
} else {
|
|
track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);
|
|
}
|
|
|
|
if (track.maxSegmentPts === undefined) {
|
|
track.maxSegmentPts = data.pts;
|
|
} else {
|
|
track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);
|
|
}
|
|
}
|
|
|
|
if (typeof data.dts === 'number') {
|
|
if (track.timelineStartInfo.dts === undefined) {
|
|
track.timelineStartInfo.dts = data.dts;
|
|
}
|
|
|
|
if (track.minSegmentDts === undefined) {
|
|
track.minSegmentDts = data.dts;
|
|
} else {
|
|
track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);
|
|
}
|
|
|
|
if (track.maxSegmentDts === undefined) {
|
|
track.maxSegmentDts = data.dts;
|
|
} else {
|
|
track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Clear values used to calculate the baseMediaDecodeTime between
|
|
* tracks
|
|
*/
|
|
clearDtsInfo = function (track) {
|
|
delete track.minSegmentDts;
|
|
delete track.maxSegmentDts;
|
|
delete track.minSegmentPts;
|
|
delete track.maxSegmentPts;
|
|
};
|
|
|
|
/**
|
|
* Calculate the track's baseMediaDecodeTime based on the earliest
|
|
* DTS the transmuxer has ever seen and the minimum DTS for the
|
|
* current track
|
|
*/
|
|
calculateTrackBaseMediaDecodeTime = function (track) {
|
|
var
|
|
oneSecondInPTS = 90000, // 90kHz clock
|
|
scale,
|
|
// Calculate the distance, in time, that this segment starts from the start
|
|
// of the timeline (earliest time seen since the transmuxer initialized)
|
|
timeSinceStartOfTimeline = track.minSegmentDts - track.timelineStartInfo.dts,
|
|
// Calculate the first sample's effective compositionTimeOffset
|
|
firstSampleCompositionOffset = track.minSegmentPts - track.minSegmentDts;
|
|
|
|
// track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where
|
|
// we want the start of the first segment to be placed
|
|
track.baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime;
|
|
|
|
// Add to that the distance this segment is from the very first
|
|
track.baseMediaDecodeTime += timeSinceStartOfTimeline;
|
|
|
|
// Subtract this segment's "compositionTimeOffset" so that the first frame of
|
|
// this segment is displayed exactly at the `baseMediaDecodeTime` or at the
|
|
// end of the previous segment
|
|
track.baseMediaDecodeTime -= firstSampleCompositionOffset;
|
|
|
|
// baseMediaDecodeTime must not become negative
|
|
track.baseMediaDecodeTime = Math.max(0, track.baseMediaDecodeTime);
|
|
|
|
if (track.type === 'audio') {
|
|
// Audio has a different clock equal to the sampling_rate so we need to
|
|
// scale the PTS values into the clock rate of the track
|
|
scale = track.samplerate / oneSecondInPTS;
|
|
track.baseMediaDecodeTime *= scale;
|
|
track.baseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A Stream that can combine multiple streams (ie. audio & video)
|
|
* into a single output segment for MSE. Also supports audio-only
|
|
* and video-only streams.
|
|
*/
|
|
CoalesceStream = function(options, metadataStream) {
|
|
// Number of Tracks per output segment
|
|
// If greater than 1, we combine multiple
|
|
// tracks into a single segment
|
|
this.numberOfTracks = 0;
|
|
this.metadataStream = metadataStream;
|
|
|
|
if (typeof options.remux !== 'undefined') {
|
|
this.remuxTracks = !!options.remux;
|
|
} else {
|
|
this.remuxTracks = true;
|
|
}
|
|
|
|
this.pendingTracks = [];
|
|
this.videoTrack = null;
|
|
this.pendingBoxes = [];
|
|
this.pendingCaptions = [];
|
|
this.pendingMetadata = [];
|
|
this.pendingBytes = 0;
|
|
this.emittedTracks = 0;
|
|
|
|
CoalesceStream.prototype.init.call(this);
|
|
|
|
// Take output from multiple
|
|
this.push = function(output) {
|
|
// buffer incoming captions until the associated video segment
|
|
// finishes
|
|
if (output.text) {
|
|
return this.pendingCaptions.push(output);
|
|
}
|
|
// buffer incoming id3 tags until the final flush
|
|
if (output.frames) {
|
|
return this.pendingMetadata.push(output);
|
|
}
|
|
|
|
// Add this track to the list of pending tracks and store
|
|
// important information required for the construction of
|
|
// the final segment
|
|
this.pendingTracks.push(output.track);
|
|
this.pendingBoxes.push(output.boxes);
|
|
this.pendingBytes += output.boxes.byteLength;
|
|
|
|
if (output.track.type === 'video') {
|
|
this.videoTrack = output.track;
|
|
}
|
|
if (output.track.type === 'audio') {
|
|
this.audioTrack = output.track;
|
|
}
|
|
};
|
|
};
|
|
|
|
CoalesceStream.prototype = new Stream();
|
|
CoalesceStream.prototype.flush = function(flushSource) {
|
|
var
|
|
offset = 0,
|
|
event = {
|
|
captions: [],
|
|
metadata: [],
|
|
info: {}
|
|
},
|
|
caption,
|
|
id3,
|
|
initSegment,
|
|
timelineStartPts = 0,
|
|
i;
|
|
|
|
if (this.pendingTracks.length < this.numberOfTracks) {
|
|
if (flushSource !== 'VideoSegmentStream' &&
|
|
flushSource !== 'AudioSegmentStream') {
|
|
// Return because we haven't received a flush from a data-generating
|
|
// portion of the segment (meaning that we have only recieved meta-data
|
|
// or captions.)
|
|
return;
|
|
} else if (this.remuxTracks) {
|
|
// Return until we have enough tracks from the pipeline to remux (if we
|
|
// are remuxing audio and video into a single MP4)
|
|
return;
|
|
} else if (this.pendingTracks.length === 0) {
|
|
// In the case where we receive a flush without any data having been
|
|
// received we consider it an emitted track for the purposes of coalescing
|
|
// `done` events.
|
|
// We do this for the case where there is an audio and video track in the
|
|
// segment but no audio data. (seen in several playlists with alternate
|
|
// audio tracks and no audio present in the main TS segments.)
|
|
this.emittedTracks++;
|
|
|
|
if (this.emittedTracks >= this.numberOfTracks) {
|
|
this.trigger('done');
|
|
this.emittedTracks = 0;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (this.videoTrack) {
|
|
timelineStartPts = this.videoTrack.timelineStartInfo.pts;
|
|
VIDEO_PROPERTIES.forEach(function(prop) {
|
|
event.info[prop] = this.videoTrack[prop];
|
|
}, this);
|
|
} else if (this.audioTrack) {
|
|
timelineStartPts = this.audioTrack.timelineStartInfo.pts;
|
|
AUDIO_PROPERTIES.forEach(function(prop) {
|
|
event.info[prop] = this.audioTrack[prop];
|
|
}, this);
|
|
}
|
|
|
|
if (this.pendingTracks.length === 1) {
|
|
event.type = this.pendingTracks[0].type;
|
|
} else {
|
|
event.type = 'combined';
|
|
}
|
|
|
|
this.emittedTracks += this.pendingTracks.length;
|
|
|
|
initSegment = mp4.initSegment(this.pendingTracks);
|
|
|
|
// Create a new typed array large enough to hold the init
|
|
// segment and all tracks
|
|
event.data = new Uint8Array(initSegment.byteLength +
|
|
this.pendingBytes);
|
|
|
|
// Create an init segment containing a moov
|
|
// and track definitions
|
|
event.data.set(initSegment);
|
|
offset += initSegment.byteLength;
|
|
|
|
// Append each moof+mdat (one per track) after the init segment
|
|
for (i = 0; i < this.pendingBoxes.length; i++) {
|
|
event.data.set(this.pendingBoxes[i], offset);
|
|
offset += this.pendingBoxes[i].byteLength;
|
|
}
|
|
|
|
// Translate caption PTS times into second offsets into the
|
|
// video timeline for the segment
|
|
for (i = 0; i < this.pendingCaptions.length; i++) {
|
|
caption = this.pendingCaptions[i];
|
|
caption.startTime = (caption.startPts - timelineStartPts);
|
|
caption.startTime /= 90e3;
|
|
caption.endTime = (caption.endPts - timelineStartPts);
|
|
caption.endTime /= 90e3;
|
|
event.captions.push(caption);
|
|
}
|
|
|
|
// Translate ID3 frame PTS times into second offsets into the
|
|
// video timeline for the segment
|
|
for (i = 0; i < this.pendingMetadata.length; i++) {
|
|
id3 = this.pendingMetadata[i];
|
|
id3.cueTime = (id3.pts - timelineStartPts);
|
|
id3.cueTime /= 90e3;
|
|
event.metadata.push(id3);
|
|
}
|
|
// We add this to every single emitted segment even though we only need
|
|
// it for the first
|
|
event.metadata.dispatchType = this.metadataStream.dispatchType;
|
|
|
|
// Reset stream state
|
|
this.pendingTracks.length = 0;
|
|
this.videoTrack = null;
|
|
this.pendingBoxes.length = 0;
|
|
this.pendingCaptions.length = 0;
|
|
this.pendingBytes = 0;
|
|
this.pendingMetadata.length = 0;
|
|
|
|
// Emit the built segment
|
|
this.trigger('data', event);
|
|
|
|
// Only emit `done` if all tracks have been flushed and emitted
|
|
if (this.emittedTracks >= this.numberOfTracks) {
|
|
this.trigger('done');
|
|
this.emittedTracks = 0;
|
|
}
|
|
};
|
|
/**
|
|
* A Stream that expects MP2T binary data as input and produces
|
|
* corresponding media segments, suitable for use with Media Source
|
|
* Extension (MSE) implementations that support the ISO BMFF byte
|
|
* stream format, like Chrome.
|
|
*/
|
|
Transmuxer = function(options) {
|
|
var
|
|
self = this,
|
|
hasFlushed = true,
|
|
videoTrack,
|
|
audioTrack;
|
|
|
|
Transmuxer.prototype.init.call(this);
|
|
|
|
options = options || {};
|
|
this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;
|
|
this.transmuxPipeline_ = {};
|
|
|
|
this.setupAacPipeline = function() {
|
|
var pipeline = {};
|
|
this.transmuxPipeline_ = pipeline;
|
|
|
|
pipeline.type = 'aac';
|
|
pipeline.metadataStream = new m2ts.MetadataStream();
|
|
|
|
// set up the parsing pipeline
|
|
pipeline.aacStream = new AacStream();
|
|
pipeline.adtsStream = new AdtsStream();
|
|
pipeline.coalesceStream = new CoalesceStream(options, pipeline.metadataStream);
|
|
pipeline.headOfPipeline = pipeline.aacStream;
|
|
|
|
pipeline.aacStream.pipe(pipeline.adtsStream);
|
|
pipeline.aacStream.pipe(pipeline.metadataStream);
|
|
pipeline.metadataStream.pipe(pipeline.coalesceStream);
|
|
|
|
pipeline.metadataStream.on('timestamp', function(frame) {
|
|
pipeline.aacStream.setTimestamp(frame.timeStamp);
|
|
});
|
|
|
|
pipeline.aacStream.on('data', function(data) {
|
|
var i;
|
|
|
|
if (data.type === 'timed-metadata' && !pipeline.audioSegmentStream) {
|
|
audioTrack = audioTrack || {
|
|
timelineStartInfo: {
|
|
baseMediaDecodeTime: self.baseMediaDecodeTime
|
|
},
|
|
codec: 'adts',
|
|
type: 'audio'
|
|
};
|
|
// hook up the audio segment stream to the first track with aac data
|
|
pipeline.coalesceStream.numberOfTracks++;
|
|
pipeline.audioSegmentStream = new AudioSegmentStream(audioTrack);
|
|
// Set up the final part of the audio pipeline
|
|
pipeline.adtsStream
|
|
.pipe(pipeline.audioSegmentStream)
|
|
.pipe(pipeline.coalesceStream);
|
|
}
|
|
});
|
|
|
|
// Re-emit any data coming from the coalesce stream to the outside world
|
|
pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
|
|
// Let the consumer know we have finished flushing the entire pipeline
|
|
pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
|
|
};
|
|
|
|
this.setupTsPipeline = function() {
|
|
var pipeline = {};
|
|
this.transmuxPipeline_ = pipeline;
|
|
|
|
pipeline.type = 'ts';
|
|
pipeline.metadataStream = new m2ts.MetadataStream();
|
|
|
|
// set up the parsing pipeline
|
|
pipeline.packetStream = new m2ts.TransportPacketStream();
|
|
pipeline.parseStream = new m2ts.TransportParseStream();
|
|
pipeline.elementaryStream = new m2ts.ElementaryStream();
|
|
pipeline.adtsStream = new AdtsStream();
|
|
pipeline.h264Stream = new H264Stream();
|
|
pipeline.captionStream = new m2ts.CaptionStream();
|
|
pipeline.coalesceStream = new CoalesceStream(options, pipeline.metadataStream);
|
|
pipeline.headOfPipeline = pipeline.packetStream;
|
|
|
|
// disassemble MPEG2-TS packets into elementary streams
|
|
pipeline.packetStream
|
|
.pipe(pipeline.parseStream)
|
|
.pipe(pipeline.elementaryStream);
|
|
|
|
// !!THIS ORDER IS IMPORTANT!!
|
|
// demux the streams
|
|
pipeline.elementaryStream
|
|
.pipe(pipeline.h264Stream);
|
|
pipeline.elementaryStream
|
|
.pipe(pipeline.adtsStream);
|
|
|
|
pipeline.elementaryStream
|
|
.pipe(pipeline.metadataStream)
|
|
.pipe(pipeline.coalesceStream);
|
|
|
|
// Hook up CEA-608/708 caption stream
|
|
pipeline.h264Stream.pipe(pipeline.captionStream)
|
|
.pipe(pipeline.coalesceStream);
|
|
|
|
pipeline.elementaryStream.on('data', function(data) {
|
|
var i;
|
|
|
|
if (data.type === 'metadata') {
|
|
i = data.tracks.length;
|
|
|
|
// scan the tracks listed in the metadata
|
|
while (i--) {
|
|
if (!videoTrack && data.tracks[i].type === 'video') {
|
|
videoTrack = data.tracks[i];
|
|
videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
|
|
} else if (!audioTrack && data.tracks[i].type === 'audio') {
|
|
audioTrack = data.tracks[i];
|
|
audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;
|
|
}
|
|
}
|
|
|
|
// hook up the video segment stream to the first track with h264 data
|
|
if (videoTrack && !pipeline.videoSegmentStream) {
|
|
pipeline.coalesceStream.numberOfTracks++;
|
|
pipeline.videoSegmentStream = new VideoSegmentStream(videoTrack);
|
|
|
|
pipeline.videoSegmentStream.on('timelineStartInfo', function(timelineStartInfo){
|
|
// When video emits timelineStartInfo data after a flush, we forward that
|
|
// info to the AudioSegmentStream, if it exists, because video timeline
|
|
// data takes precedence.
|
|
if (audioTrack) {
|
|
audioTrack.timelineStartInfo = timelineStartInfo;
|
|
// On the first segment we trim AAC frames that exist before the
|
|
// very earliest DTS we have seen in video because Chrome will
|
|
// interpret any video track with a baseMediaDecodeTime that is
|
|
// non-zero as a gap.
|
|
pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts);
|
|
}
|
|
});
|
|
|
|
// Set up the final part of the video pipeline
|
|
pipeline.h264Stream
|
|
.pipe(pipeline.videoSegmentStream)
|
|
.pipe(pipeline.coalesceStream);
|
|
}
|
|
|
|
if (audioTrack && !pipeline.audioSegmentStream) {
|
|
// hook up the audio segment stream to the first track with aac data
|
|
pipeline.coalesceStream.numberOfTracks++;
|
|
pipeline.audioSegmentStream = new AudioSegmentStream(audioTrack);
|
|
|
|
// Set up the final part of the audio pipeline
|
|
pipeline.adtsStream
|
|
.pipe(pipeline.audioSegmentStream)
|
|
.pipe(pipeline.coalesceStream);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Re-emit any data coming from the coalesce stream to the outside world
|
|
pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));
|
|
// Let the consumer know we have finished flushing the entire pipeline
|
|
pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));
|
|
};
|
|
|
|
// hook up the segment streams once track metadata is delivered
|
|
this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {
|
|
var pipeline = this.transmuxPipeline_;
|
|
|
|
this.baseMediaDecodeTime = baseMediaDecodeTime;
|
|
if (audioTrack) {
|
|
audioTrack.timelineStartInfo.dts = undefined;
|
|
audioTrack.timelineStartInfo.pts = undefined;
|
|
clearDtsInfo(audioTrack);
|
|
audioTrack.timelineStartInfo.baseMediaDecodeTime = baseMediaDecodeTime;
|
|
}
|
|
if (videoTrack) {
|
|
if (pipeline.videoSegmentStream) {
|
|
pipeline.videoSegmentStream.gopCache_ = [];
|
|
}
|
|
videoTrack.timelineStartInfo.dts = undefined;
|
|
videoTrack.timelineStartInfo.pts = undefined;
|
|
clearDtsInfo(videoTrack);
|
|
videoTrack.timelineStartInfo.baseMediaDecodeTime = baseMediaDecodeTime;
|
|
}
|
|
};
|
|
|
|
// feed incoming data to the front of the parsing pipeline
|
|
this.push = function(data) {
|
|
if (hasFlushed) {
|
|
var isAac = isLikelyAacData(data);
|
|
|
|
if (isAac && this.transmuxPipeline_.type !== 'aac') {
|
|
this.setupAacPipeline();
|
|
} else if (!isAac && this.transmuxPipeline_.type !== 'ts') {
|
|
this.setupTsPipeline();
|
|
}
|
|
hasFlushed = false;
|
|
}
|
|
this.transmuxPipeline_.headOfPipeline.push(data);
|
|
};
|
|
|
|
// flush any buffered data
|
|
this.flush = function() {
|
|
hasFlushed = true;
|
|
// Start at the top of the pipeline and flush all pending work
|
|
this.transmuxPipeline_.headOfPipeline.flush();
|
|
};
|
|
};
|
|
Transmuxer.prototype = new Stream();
|
|
|
|
module.exports = {
|
|
Transmuxer: Transmuxer,
|
|
VideoSegmentStream: VideoSegmentStream,
|
|
AudioSegmentStream: AudioSegmentStream,
|
|
AUDIO_PROPERTIES: AUDIO_PROPERTIES,
|
|
VIDEO_PROPERTIES: VIDEO_PROPERTIES
|
|
};
|
|
|
|
},{"../aac":36,"../codecs/adts.js":37,"../codecs/h264":38,"../m2ts/m2ts.js":46,"../utils/stream.js":55,"./mp4-generator.js":50}],52:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var
|
|
tagTypes = {
|
|
0x08: 'audio',
|
|
0x09: 'video',
|
|
0x12: 'metadata'
|
|
},
|
|
hex = function (val) {
|
|
return '0x' + ('00' + val.toString(16)).slice(-2).toUpperCase();
|
|
},
|
|
hexStringList = function (data) {
|
|
var arr = [], i;
|
|
/* jshint -W086 */
|
|
while(data.byteLength > 0) {
|
|
i = 0;
|
|
switch(data.byteLength) {
|
|
default:
|
|
arr.push(hex(data[i++]));
|
|
case 7:
|
|
arr.push(hex(data[i++]));
|
|
case 6:
|
|
arr.push(hex(data[i++]));
|
|
case 5:
|
|
arr.push(hex(data[i++]));
|
|
case 4:
|
|
arr.push(hex(data[i++]));
|
|
case 3:
|
|
arr.push(hex(data[i++]));
|
|
case 2:
|
|
arr.push(hex(data[i++]));
|
|
case 1:
|
|
arr.push(hex(data[i++]));
|
|
}
|
|
data = data.subarray(i);
|
|
}
|
|
/* jshint +W086 */
|
|
return arr.join(' ');
|
|
},
|
|
parseAVCTag = function (tag, obj) {
|
|
var
|
|
avcPacketTypes = [
|
|
'AVC Sequence Header',
|
|
'AVC NALU',
|
|
'AVC End-of-Sequence'
|
|
],
|
|
nalUnitTypes = [
|
|
'unspecified',
|
|
'slice_layer_without_partitioning',
|
|
'slice_data_partition_a_layer',
|
|
'slice_data_partition_b_layer',
|
|
'slice_data_partition_c_layer',
|
|
'slice_layer_without_partitioning_idr',
|
|
'sei',
|
|
'seq_parameter_set',
|
|
'pic_parameter_set',
|
|
'access_unit_delimiter',
|
|
'end_of_seq',
|
|
'end_of_stream',
|
|
'filler',
|
|
'seq_parameter_set_ext',
|
|
'prefix_nal_unit',
|
|
'subset_seq_parameter_set',
|
|
'reserved',
|
|
'reserved',
|
|
'reserved'
|
|
],
|
|
compositionTime = (tag[1] & parseInt('01111111', 2) << 16) | (tag[2] << 8) | tag[3];
|
|
|
|
obj = obj || {};
|
|
|
|
obj.avcPacketType = avcPacketTypes[tag[0]];
|
|
obj.CompositionTime = (tag[1] & parseInt('10000000', 2)) ? -compositionTime : compositionTime;
|
|
|
|
if (tag[0] === 1) {
|
|
obj.nalUnitTypeRaw = hexStringList(tag.subarray(4, 100));
|
|
} else {
|
|
obj.data = hexStringList(tag.subarray(4));
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
parseVideoTag = function (tag, obj) {
|
|
var
|
|
frameTypes = [
|
|
'Unknown',
|
|
'Keyframe (for AVC, a seekable frame)',
|
|
'Inter frame (for AVC, a nonseekable frame)',
|
|
'Disposable inter frame (H.263 only)',
|
|
'Generated keyframe (reserved for server use only)',
|
|
'Video info/command frame'
|
|
],
|
|
codecIDs = [
|
|
'JPEG (currently unused)',
|
|
'Sorenson H.263',
|
|
'Screen video',
|
|
'On2 VP6',
|
|
'On2 VP6 with alpha channel',
|
|
'Screen video version 2',
|
|
'AVC'
|
|
],
|
|
codecID = tag[0] & parseInt('00001111', 2);
|
|
|
|
obj = obj || {};
|
|
|
|
obj.frameType = frameTypes[(tag[0] & parseInt('11110000', 2)) >>> 4];
|
|
obj.codecID = codecID;
|
|
|
|
if (codecID === 7) {
|
|
return parseAVCTag(tag.subarray(1), obj);
|
|
}
|
|
return obj;
|
|
},
|
|
parseAACTag = function (tag, obj) {
|
|
var packetTypes = [
|
|
'AAC Sequence Header',
|
|
'AAC Raw'
|
|
];
|
|
|
|
obj = obj || {};
|
|
|
|
obj.aacPacketType = packetTypes[tag[0]];
|
|
obj.data = hexStringList(tag.subarray(1));
|
|
|
|
return obj;
|
|
},
|
|
parseAudioTag = function (tag, obj) {
|
|
var
|
|
formatTable = [
|
|
'Linear PCM, platform endian',
|
|
'ADPCM',
|
|
'MP3',
|
|
'Linear PCM, little endian',
|
|
'Nellymoser 16-kHz mono',
|
|
'Nellymoser 8-kHz mono',
|
|
'Nellymoser',
|
|
'G.711 A-law logarithmic PCM',
|
|
'G.711 mu-law logarithmic PCM',
|
|
'reserved',
|
|
'AAC',
|
|
'Speex',
|
|
'MP3 8-Khz',
|
|
'Device-specific sound'
|
|
],
|
|
samplingRateTable = [
|
|
'5.5-kHz',
|
|
'11-kHz',
|
|
'22-kHz',
|
|
'44-kHz'
|
|
],
|
|
soundFormat = (tag[0] & parseInt('11110000', 2)) >>> 4;
|
|
|
|
obj = obj || {};
|
|
|
|
obj.soundFormat = formatTable[soundFormat];
|
|
obj.soundRate = samplingRateTable[(tag[0] & parseInt('00001100', 2)) >>> 2];
|
|
obj.soundSize = ((tag[0] & parseInt('00000010', 2)) >>> 1) ? '16-bit' : '8-bit';
|
|
obj.soundType = (tag[0] & parseInt('00000001', 2)) ? 'Stereo' : 'Mono';
|
|
|
|
if (soundFormat === 10) {
|
|
return parseAACTag(tag.subarray(1), obj);
|
|
}
|
|
return obj;
|
|
},
|
|
parseGenericTag = function (tag) {
|
|
return {
|
|
tagType: tagTypes[tag[0]],
|
|
dataSize: (tag[1] << 16) | (tag[2] << 8) | tag[3],
|
|
timestamp: (tag[7] << 24) | (tag[4] << 16) | (tag[5] << 8) | tag[6],
|
|
streamID: (tag[8] << 16) | (tag[9] << 8) | tag[10]
|
|
};
|
|
},
|
|
inspectFlvTag = function (tag) {
|
|
var header = parseGenericTag(tag);
|
|
switch (tag[0]) {
|
|
case 0x08:
|
|
parseAudioTag(tag.subarray(11), header);
|
|
break;
|
|
case 0x09:
|
|
parseVideoTag(tag.subarray(11), header);
|
|
break;
|
|
case 0x12:
|
|
}
|
|
return header;
|
|
},
|
|
inspectFlv = function (bytes) {
|
|
var i = 9, // header
|
|
dataSize,
|
|
parsedResults = [],
|
|
tag;
|
|
|
|
// traverse the tags
|
|
i += 4; // skip previous tag size
|
|
while (i < bytes.byteLength) {
|
|
dataSize = bytes[i + 1] << 16;
|
|
dataSize |= bytes[i + 2] << 8;
|
|
dataSize |= bytes[i + 3];
|
|
dataSize += 11;
|
|
|
|
tag = bytes.subarray(i, i + dataSize);
|
|
parsedResults.push(inspectFlvTag(tag));
|
|
i += dataSize + 4;
|
|
}
|
|
return parsedResults;
|
|
},
|
|
textifyFlv = function (flvTagArray) {
|
|
return JSON.stringify(flvTagArray, null, 2);
|
|
};
|
|
|
|
module.exports = {
|
|
inspectTag: inspectFlvTag,
|
|
inspect: inspectFlv,
|
|
textify: textifyFlv
|
|
};
|
|
|
|
},{}],53:[function(require,module,exports){
|
|
(function (global){
|
|
'use strict';
|
|
|
|
var
|
|
inspectMp4,
|
|
textifyMp4,
|
|
/**
|
|
* Returns the string representation of an ASCII encoded four byte buffer.
|
|
* @param buffer {Uint8Array} a four-byte buffer to translate
|
|
* @return {string} the corresponding string
|
|
*/
|
|
parseType = function(buffer) {
|
|
var result = '';
|
|
result += String.fromCharCode(buffer[0]);
|
|
result += String.fromCharCode(buffer[1]);
|
|
result += String.fromCharCode(buffer[2]);
|
|
result += String.fromCharCode(buffer[3]);
|
|
return result;
|
|
},
|
|
parseMp4Date = function(seconds) {
|
|
return new Date(seconds * 1000 - 2082844800000);
|
|
},
|
|
parseSampleFlags = function(flags) {
|
|
return {
|
|
isLeading: (flags[0] & 0x0c) >>> 2,
|
|
dependsOn: flags[0] & 0x03,
|
|
isDependedOn: (flags[1] & 0xc0) >>> 6,
|
|
hasRedundancy: (flags[1] & 0x30) >>> 4,
|
|
paddingValue: (flags[1] & 0x0e) >>> 1,
|
|
isNonSyncSample: flags[1] & 0x01,
|
|
degradationPriority: (flags[2] << 8) | flags[3]
|
|
};
|
|
},
|
|
nalParse = function(avcStream) {
|
|
var
|
|
avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),
|
|
result = [],
|
|
i,
|
|
length;
|
|
for (i = 0; i + 4 < avcStream.length; i += length) {
|
|
length = avcView.getUint32(i);
|
|
i += 4;
|
|
|
|
// bail if this doesn't appear to be an H264 stream
|
|
if (length <= 0) {
|
|
result.push('<span style=\'color:red;\'>MALFORMED DATA</span>');
|
|
continue;
|
|
}
|
|
|
|
switch(avcStream[i] & 0x1F) {
|
|
case 0x01:
|
|
result.push('slice_layer_without_partitioning_rbsp');
|
|
break;
|
|
case 0x05:
|
|
result.push('slice_layer_without_partitioning_rbsp_idr');
|
|
break;
|
|
case 0x06:
|
|
result.push('sei_rbsp');
|
|
break;
|
|
case 0x07:
|
|
result.push('seq_parameter_set_rbsp');
|
|
break;
|
|
case 0x08:
|
|
result.push('pic_parameter_set_rbsp');
|
|
break;
|
|
case 0x09:
|
|
result.push('access_unit_delimiter_rbsp');
|
|
break;
|
|
default:
|
|
result.push('UNKNOWN NAL - ' + avcStream[i] & 0x1F);
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
// registry of handlers for individual mp4 box types
|
|
parse = {
|
|
// codingname, not a first-class box type. stsd entries share the
|
|
// same format as real boxes so the parsing infrastructure can be
|
|
// shared
|
|
avc1: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
return {
|
|
dataReferenceIndex: view.getUint16(6),
|
|
width: view.getUint16(24),
|
|
height: view.getUint16(26),
|
|
horizresolution: view.getUint16(28) + (view.getUint16(30) / 16),
|
|
vertresolution: view.getUint16(32) + (view.getUint16(34) / 16),
|
|
frameCount: view.getUint16(40),
|
|
depth: view.getUint16(74),
|
|
config: inspectMp4(data.subarray(78, data.byteLength))
|
|
};
|
|
},
|
|
avcC: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
configurationVersion: data[0],
|
|
avcProfileIndication: data[1],
|
|
profileCompatibility: data[2],
|
|
avcLevelIndication: data[3],
|
|
lengthSizeMinusOne: data[4] & 0x03,
|
|
sps: [],
|
|
pps: []
|
|
},
|
|
numOfSequenceParameterSets = data[5] & 0x1f,
|
|
numOfPictureParameterSets,
|
|
nalSize,
|
|
offset,
|
|
i;
|
|
|
|
// iterate past any SPSs
|
|
offset = 6;
|
|
for (i = 0; i < numOfSequenceParameterSets; i++) {
|
|
nalSize = view.getUint16(offset);
|
|
offset += 2;
|
|
result.sps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));
|
|
offset += nalSize;
|
|
}
|
|
// iterate past any PPSs
|
|
numOfPictureParameterSets = data[offset];
|
|
offset++;
|
|
for (i = 0; i < numOfPictureParameterSets; i++) {
|
|
nalSize = view.getUint16(offset);
|
|
offset += 2;
|
|
result.pps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));
|
|
offset += nalSize;
|
|
}
|
|
return result;
|
|
},
|
|
btrt: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
return {
|
|
bufferSizeDB: view.getUint32(0),
|
|
maxBitrate: view.getUint32(4),
|
|
avgBitrate: view.getUint32(8)
|
|
};
|
|
},
|
|
esds: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
esId: (data[6] << 8) | data[7],
|
|
streamPriority: data[8] & 0x1f,
|
|
decoderConfig: {
|
|
objectProfileIndication: data[11],
|
|
streamType: (data[12] >>> 2) & 0x3f,
|
|
bufferSize: (data[13] << 16) | (data[14] << 8) | data[15],
|
|
maxBitrate: (data[16] << 24) |
|
|
(data[17] << 16) |
|
|
(data[18] << 8) |
|
|
data[19],
|
|
avgBitrate: (data[20] << 24) |
|
|
(data[21] << 16) |
|
|
(data[22] << 8) |
|
|
data[23],
|
|
decoderConfigDescriptor: {
|
|
tag: data[24],
|
|
length: data[25],
|
|
audioObjectType: (data[26] >>> 3) & 0x1f,
|
|
samplingFrequencyIndex: ((data[26] & 0x07) << 1) |
|
|
((data[27] >>> 7) & 0x01),
|
|
channelConfiguration: (data[27] >>> 3) & 0x0f
|
|
}
|
|
}
|
|
};
|
|
},
|
|
ftyp: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
majorBrand: parseType(data.subarray(0, 4)),
|
|
minorVersion: view.getUint32(4),
|
|
compatibleBrands: []
|
|
},
|
|
i = 8;
|
|
while (i < data.byteLength) {
|
|
result.compatibleBrands.push(parseType(data.subarray(i, i + 4)));
|
|
i += 4;
|
|
}
|
|
return result;
|
|
},
|
|
dinf: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
dref: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
dataReferences: inspectMp4(data.subarray(8))
|
|
};
|
|
},
|
|
hdlr: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
language,
|
|
result = {
|
|
version: view.getUint8(0),
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
handlerType: parseType(data.subarray(8, 12)),
|
|
name: ''
|
|
},
|
|
i = 8;
|
|
|
|
// parse out the name field
|
|
for (i = 24; i < data.byteLength; i++) {
|
|
if (data[i] === 0x00) {
|
|
// the name field is null-terminated
|
|
i++;
|
|
break;
|
|
}
|
|
result.name += String.fromCharCode(data[i]);
|
|
}
|
|
// decode UTF-8 to javascript's internal representation
|
|
// see http://ecmanaut.blogspot.com/2006/07/encoding-decoding-utf8-in-javascript.html
|
|
result.name = decodeURIComponent(global.escape(result.name));
|
|
|
|
return result;
|
|
},
|
|
mdat: function(data) {
|
|
return {
|
|
byteLength: data.byteLength,
|
|
nals: nalParse(data)
|
|
};
|
|
},
|
|
mdhd: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
i = 4,
|
|
language,
|
|
result = {
|
|
version: view.getUint8(0),
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
language: ''
|
|
};
|
|
if (result.version === 1) {
|
|
i += 4;
|
|
result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 8;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 4;
|
|
result.timescale = view.getUint32(i);
|
|
i += 8;
|
|
result.duration = view.getUint32(i); // truncating top 4 bytes
|
|
} else {
|
|
result.creationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.timescale = view.getUint32(i);
|
|
i += 4;
|
|
result.duration = view.getUint32(i);
|
|
}
|
|
i += 4;
|
|
// language is stored as an ISO-639-2/T code in an array of three 5-bit fields
|
|
// each field is the packed difference between its ASCII value and 0x60
|
|
language = view.getUint16(i);
|
|
result.language += String.fromCharCode((language >> 10) + 0x60);
|
|
result.language += String.fromCharCode(((language & 0x03c0) >> 5) + 0x60);
|
|
result.language += String.fromCharCode((language & 0x1f) + 0x60);
|
|
|
|
return result;
|
|
},
|
|
mdia: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
mfhd: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
sequenceNumber: (data[4] << 24) |
|
|
(data[5] << 16) |
|
|
(data[6] << 8) |
|
|
(data[7])
|
|
};
|
|
},
|
|
minf: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
// codingname, not a first-class box type. stsd entries share the
|
|
// same format as real boxes so the parsing infrastructure can be
|
|
// shared
|
|
mp4a: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
// 6 bytes reserved
|
|
dataReferenceIndex: view.getUint16(6),
|
|
// 4 + 4 bytes reserved
|
|
channelcount: view.getUint16(16),
|
|
samplesize: view.getUint16(18),
|
|
// 2 bytes pre_defined
|
|
// 2 bytes reserved
|
|
samplerate: view.getUint16(24) + (view.getUint16(26) / 65536)
|
|
};
|
|
|
|
// if there are more bytes to process, assume this is an ISO/IEC
|
|
// 14496-14 MP4AudioSampleEntry and parse the ESDBox
|
|
if (data.byteLength > 28) {
|
|
result.streamDescriptor = inspectMp4(data.subarray(28))[0];
|
|
}
|
|
return result;
|
|
},
|
|
moof: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
moov: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
mvex: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
mvhd: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
i = 4,
|
|
result = {
|
|
version: view.getUint8(0),
|
|
flags: new Uint8Array(data.subarray(1, 4))
|
|
};
|
|
|
|
if (result.version === 1) {
|
|
i += 4;
|
|
result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 8;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 4;
|
|
result.timescale = view.getUint32(i);
|
|
i += 8;
|
|
result.duration = view.getUint32(i); // truncating top 4 bytes
|
|
} else {
|
|
result.creationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.timescale = view.getUint32(i);
|
|
i += 4;
|
|
result.duration = view.getUint32(i);
|
|
}
|
|
i += 4;
|
|
|
|
// convert fixed-point, base 16 back to a number
|
|
result.rate = view.getUint16(i) + (view.getUint16(i + 2) / 16);
|
|
i += 4;
|
|
result.volume = view.getUint8(i) + (view.getUint8(i + 1) / 8);
|
|
i += 2;
|
|
i += 2;
|
|
i += 2 * 4;
|
|
result.matrix = new Uint32Array(data.subarray(i, i + (9 * 4)));
|
|
i += 9 * 4;
|
|
i += 6 * 4;
|
|
result.nextTrackId = view.getUint32(i);
|
|
return result;
|
|
},
|
|
pdin: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
return {
|
|
version: view.getUint8(0),
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
rate: view.getUint32(4),
|
|
initialDelay: view.getUint32(8)
|
|
};
|
|
},
|
|
sdtp: function(data) {
|
|
var
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
samples: []
|
|
}, i;
|
|
|
|
for (i = 4; i < data.byteLength; i++) {
|
|
result.samples.push({
|
|
dependsOn: (data[i] & 0x30) >> 4,
|
|
isDependedOn: (data[i] & 0x0c) >> 2,
|
|
hasRedundancy: data[i] & 0x03
|
|
});
|
|
}
|
|
return result;
|
|
},
|
|
sidx: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
references: [],
|
|
referenceId: view.getUint32(4),
|
|
timescale: view.getUint32(8),
|
|
earliestPresentationTime: view.getUint32(12),
|
|
firstOffset: view.getUint32(16)
|
|
},
|
|
referenceCount = view.getUint16(22),
|
|
i;
|
|
|
|
for (i = 24; referenceCount; i += 12, referenceCount-- ) {
|
|
result.references.push({
|
|
referenceType: (data[i] & 0x80) >>> 7,
|
|
referencedSize: view.getUint32(i) & 0x7FFFFFFF,
|
|
subsegmentDuration: view.getUint32(i + 4),
|
|
startsWithSap: !!(data[i + 8] & 0x80),
|
|
sapType: (data[i + 8] & 0x70) >>> 4,
|
|
sapDeltaTime: view.getUint32(i + 8) & 0x0FFFFFFF
|
|
});
|
|
}
|
|
|
|
return result;
|
|
},
|
|
smhd: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
balance: data[4] + (data[5] / 256)
|
|
};
|
|
},
|
|
stbl: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
stco: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
chunkOffsets: []
|
|
},
|
|
entryCount = view.getUint32(4),
|
|
i;
|
|
for (i = 8; entryCount; i += 4, entryCount--) {
|
|
result.chunkOffsets.push(view.getUint32(i));
|
|
}
|
|
return result;
|
|
},
|
|
stsc: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
entryCount = view.getUint32(4),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
sampleToChunks: []
|
|
},
|
|
i;
|
|
for (i = 8; entryCount; i += 12, entryCount--) {
|
|
result.sampleToChunks.push({
|
|
firstChunk: view.getUint32(i),
|
|
samplesPerChunk: view.getUint32(i + 4),
|
|
sampleDescriptionIndex: view.getUint32(i + 8)
|
|
});
|
|
}
|
|
return result;
|
|
},
|
|
stsd: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
sampleDescriptions: inspectMp4(data.subarray(8))
|
|
};
|
|
},
|
|
stsz: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
sampleSize: view.getUint32(4),
|
|
entries: []
|
|
},
|
|
i;
|
|
for (i = 12; i < data.byteLength; i += 4) {
|
|
result.entries.push(view.getUint32(i));
|
|
}
|
|
return result;
|
|
},
|
|
stts: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
timeToSamples: []
|
|
},
|
|
entryCount = view.getUint32(4),
|
|
i;
|
|
|
|
for (i = 8; entryCount; i += 8, entryCount--) {
|
|
result.timeToSamples.push({
|
|
sampleCount: view.getUint32(i),
|
|
sampleDelta: view.getUint32(i + 4)
|
|
});
|
|
}
|
|
return result;
|
|
},
|
|
styp: function(data) {
|
|
return parse.ftyp(data);
|
|
},
|
|
tfdt: function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
baseMediaDecodeTime: data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]
|
|
};
|
|
},
|
|
tfhd: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
trackId: view.getUint32(4)
|
|
},
|
|
baseDataOffsetPresent = result.flags[2] & 0x01,
|
|
sampleDescriptionIndexPresent = result.flags[2] & 0x02,
|
|
defaultSampleDurationPresent = result.flags[2] & 0x08,
|
|
defaultSampleSizePresent = result.flags[2] & 0x10,
|
|
defaultSampleFlagsPresent = result.flags[2] & 0x20,
|
|
i;
|
|
|
|
i = 8;
|
|
if (baseDataOffsetPresent) {
|
|
i += 4; // truncate top 4 bytes
|
|
result.baseDataOffset = view.getUint32(12);
|
|
i += 4;
|
|
}
|
|
if (sampleDescriptionIndexPresent) {
|
|
result.sampleDescriptionIndex = view.getUint32(i);
|
|
i += 4;
|
|
}
|
|
if (defaultSampleDurationPresent) {
|
|
result.defaultSampleDuration = view.getUint32(i);
|
|
i += 4;
|
|
}
|
|
if (defaultSampleSizePresent) {
|
|
result.defaultSampleSize = view.getUint32(i);
|
|
i += 4;
|
|
}
|
|
if (defaultSampleFlagsPresent) {
|
|
result.defaultSampleFlags = view.getUint32(i);
|
|
}
|
|
return result;
|
|
},
|
|
tkhd: function(data) {
|
|
var
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
i = 4,
|
|
result = {
|
|
version: view.getUint8(0),
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
};
|
|
if (result.version === 1) {
|
|
i += 4;
|
|
result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 8;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
|
|
i += 4;
|
|
result.trackId = view.getUint32(i);
|
|
i += 4;
|
|
i += 8;
|
|
result.duration = view.getUint32(i); // truncating top 4 bytes
|
|
} else {
|
|
result.creationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.modificationTime = parseMp4Date(view.getUint32(i));
|
|
i += 4;
|
|
result.trackId = view.getUint32(i);
|
|
i += 4;
|
|
i += 4;
|
|
result.duration = view.getUint32(i);
|
|
}
|
|
i += 4;
|
|
i += 2 * 4;
|
|
result.layer = view.getUint16(i);
|
|
i += 2;
|
|
result.alternateGroup = view.getUint16(i);
|
|
i += 2;
|
|
// convert fixed-point, base 16 back to a number
|
|
result.volume = view.getUint8(i) + (view.getUint8(i + 1) / 8);
|
|
i += 2;
|
|
i += 2;
|
|
result.matrix = new Uint32Array(data.subarray(i, i + (9 * 4)));
|
|
i += 9 * 4;
|
|
result.width = view.getUint16(i) + (view.getUint16(i + 2) / 16);
|
|
i += 4;
|
|
result.height = view.getUint16(i) + (view.getUint16(i + 2) / 16);
|
|
return result;
|
|
},
|
|
traf: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
trak: function(data) {
|
|
return {
|
|
boxes: inspectMp4(data)
|
|
};
|
|
},
|
|
trex: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
trackId: view.getUint32(4),
|
|
defaultSampleDescriptionIndex: view.getUint32(8),
|
|
defaultSampleDuration: view.getUint32(12),
|
|
defaultSampleSize: view.getUint32(16),
|
|
sampleDependsOn: data[20] & 0x03,
|
|
sampleIsDependedOn: (data[21] & 0xc0) >> 6,
|
|
sampleHasRedundancy: (data[21] & 0x30) >> 4,
|
|
samplePaddingValue: (data[21] & 0x0e) >> 1,
|
|
sampleIsDifferenceSample: !!(data[21] & 0x01),
|
|
sampleDegradationPriority: view.getUint16(22)
|
|
};
|
|
},
|
|
trun: function(data) {
|
|
var
|
|
result = {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
samples: []
|
|
},
|
|
view = new DataView(data.buffer, data.byteOffset, data.byteLength),
|
|
dataOffsetPresent = result.flags[2] & 0x01,
|
|
firstSampleFlagsPresent = result.flags[2] & 0x04,
|
|
sampleDurationPresent = result.flags[1] & 0x01,
|
|
sampleSizePresent = result.flags[1] & 0x02,
|
|
sampleFlagsPresent = result.flags[1] & 0x04,
|
|
sampleCompositionTimeOffsetPresent = result.flags[1] & 0x08,
|
|
sampleCount = view.getUint32(4),
|
|
offset = 8,
|
|
sample;
|
|
|
|
if (dataOffsetPresent) {
|
|
result.dataOffset = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
|
|
if (firstSampleFlagsPresent && sampleCount) {
|
|
sample = {
|
|
flags: parseSampleFlags(data.subarray(offset, offset + 4))
|
|
};
|
|
offset += 4;
|
|
if (sampleDurationPresent) {
|
|
sample.duration = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
if (sampleSizePresent) {
|
|
sample.size = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
if (sampleCompositionTimeOffsetPresent) {
|
|
sample.compositionTimeOffset = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
result.samples.push(sample);
|
|
sampleCount--;
|
|
}
|
|
|
|
while (sampleCount--) {
|
|
sample = {};
|
|
if (sampleDurationPresent) {
|
|
sample.duration = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
if (sampleSizePresent) {
|
|
sample.size = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
if (sampleFlagsPresent) {
|
|
sample.flags = parseSampleFlags(data.subarray(offset, offset + 4));
|
|
offset += 4;
|
|
}
|
|
if (sampleCompositionTimeOffsetPresent) {
|
|
sample.compositionTimeOffset = view.getUint32(offset);
|
|
offset += 4;
|
|
}
|
|
result.samples.push(sample);
|
|
}
|
|
return result;
|
|
},
|
|
'url ': function(data) {
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4))
|
|
};
|
|
},
|
|
vmhd: function(data) {
|
|
var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
return {
|
|
version: data[0],
|
|
flags: new Uint8Array(data.subarray(1, 4)),
|
|
graphicsmode: view.getUint16(4),
|
|
opcolor: new Uint16Array([view.getUint16(6),
|
|
view.getUint16(8),
|
|
view.getUint16(10)])
|
|
};
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Return a javascript array of box objects parsed from an ISO base
|
|
* media file.
|
|
* @param data {Uint8Array} the binary data of the media to be inspected
|
|
* @return {array} a javascript array of potentially nested box objects
|
|
*/
|
|
inspectMp4 = function(data) {
|
|
var
|
|
i = 0,
|
|
result = [],
|
|
view,
|
|
size,
|
|
type,
|
|
end,
|
|
box;
|
|
|
|
// Convert data from Uint8Array to ArrayBuffer, to follow Dataview API
|
|
var ab = new ArrayBuffer(data.length);
|
|
var v = new Uint8Array(ab);
|
|
for (var z = 0; z < data.length; ++z) {
|
|
v[z] = data[z];
|
|
}
|
|
view = new DataView(ab);
|
|
|
|
|
|
while (i < data.byteLength) {
|
|
// parse box data
|
|
size = view.getUint32(i);
|
|
type = parseType(data.subarray(i + 4, i + 8));
|
|
end = size > 1 ? i + size : data.byteLength;
|
|
|
|
// parse type-specific data
|
|
box = (parse[type] || function(data) {
|
|
return {
|
|
data: data
|
|
};
|
|
})(data.subarray(i + 8, end));
|
|
box.size = size;
|
|
box.type = type;
|
|
|
|
// store this box and move to the next
|
|
result.push(box);
|
|
i = end;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Returns a textual representation of the javascript represtentation
|
|
* of an MP4 file. You can use it as an alternative to
|
|
* JSON.stringify() to compare inspected MP4s.
|
|
* @param inspectedMp4 {array} the parsed array of boxes in an MP4
|
|
* file
|
|
* @param depth {number} (optional) the number of ancestor boxes of
|
|
* the elements of inspectedMp4. Assumed to be zero if unspecified.
|
|
* @return {string} a text representation of the parsed MP4
|
|
*/
|
|
textifyMp4 = function(inspectedMp4, depth) {
|
|
var indent;
|
|
depth = depth || 0;
|
|
indent = new Array(depth * 2 + 1).join(' ');
|
|
|
|
// iterate over all the boxes
|
|
return inspectedMp4.map(function(box, index) {
|
|
|
|
// list the box type first at the current indentation level
|
|
return indent + box.type + '\n' +
|
|
|
|
// the type is already included and handle child boxes separately
|
|
Object.keys(box).filter(function(key) {
|
|
return key !== 'type' && key !== 'boxes';
|
|
|
|
// output all the box properties
|
|
}).map(function(key) {
|
|
var prefix = indent + ' ' + key + ': ',
|
|
value = box[key];
|
|
|
|
// print out raw bytes as hexademical
|
|
if (value instanceof Uint8Array || value instanceof Uint32Array) {
|
|
var bytes = Array.prototype.slice.call(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))
|
|
.map(function(byte) {
|
|
return ' ' + ('00' + byte.toString(16)).slice(-2);
|
|
}).join('').match(/.{1,24}/g);
|
|
if (!bytes) {
|
|
return prefix + '<>';
|
|
}
|
|
if (bytes.length === 1) {
|
|
return prefix + '<' + bytes.join('').slice(1) + '>';
|
|
}
|
|
return prefix + '<\n' + bytes.map(function(line) {
|
|
return indent + ' ' + line;
|
|
}).join('\n') + '\n' + indent + ' >';
|
|
}
|
|
|
|
// stringify generic objects
|
|
return prefix +
|
|
JSON.stringify(value, null, 2)
|
|
.split('\n').map(function(line, index) {
|
|
if (index === 0) {
|
|
return line;
|
|
}
|
|
return indent + ' ' + line;
|
|
}).join('\n');
|
|
}).join('\n') +
|
|
|
|
// recursively textify the child boxes
|
|
(box.boxes ? '\n' + textifyMp4(box.boxes, depth + 1) : '');
|
|
}).join('\n');
|
|
};
|
|
|
|
module.exports = {
|
|
inspect: inspectMp4,
|
|
textify: textifyMp4
|
|
};
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],54:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var ExpGolomb;
|
|
|
|
/**
|
|
* Parser for exponential Golomb codes, a variable-bitwidth number encoding
|
|
* scheme used by h264.
|
|
*/
|
|
ExpGolomb = function(workingData) {
|
|
var
|
|
// the number of bytes left to examine in workingData
|
|
workingBytesAvailable = workingData.byteLength,
|
|
|
|
// the current word being examined
|
|
workingWord = 0, // :uint
|
|
|
|
// the number of bits left to examine in the current word
|
|
workingBitsAvailable = 0; // :uint;
|
|
|
|
// ():uint
|
|
this.length = function() {
|
|
return (8 * workingBytesAvailable);
|
|
};
|
|
|
|
// ():uint
|
|
this.bitsAvailable = function() {
|
|
return (8 * workingBytesAvailable) + workingBitsAvailable;
|
|
};
|
|
|
|
// ():void
|
|
this.loadWord = function() {
|
|
var
|
|
position = workingData.byteLength - workingBytesAvailable,
|
|
workingBytes = new Uint8Array(4),
|
|
availableBytes = Math.min(4, workingBytesAvailable);
|
|
|
|
if (availableBytes === 0) {
|
|
throw new Error('no bytes available');
|
|
}
|
|
|
|
workingBytes.set(workingData.subarray(position,
|
|
position + availableBytes));
|
|
workingWord = new DataView(workingBytes.buffer).getUint32(0);
|
|
|
|
// track the amount of workingData that has been processed
|
|
workingBitsAvailable = availableBytes * 8;
|
|
workingBytesAvailable -= availableBytes;
|
|
};
|
|
|
|
// (count:int):void
|
|
this.skipBits = function(count) {
|
|
var skipBytes; // :int
|
|
if (workingBitsAvailable > count) {
|
|
workingWord <<= count;
|
|
workingBitsAvailable -= count;
|
|
} else {
|
|
count -= workingBitsAvailable;
|
|
skipBytes = Math.floor(count / 8);
|
|
|
|
count -= (skipBytes * 8);
|
|
workingBytesAvailable -= skipBytes;
|
|
|
|
this.loadWord();
|
|
|
|
workingWord <<= count;
|
|
workingBitsAvailable -= count;
|
|
}
|
|
};
|
|
|
|
// (size:int):uint
|
|
this.readBits = function(size) {
|
|
var
|
|
bits = Math.min(workingBitsAvailable, size), // :uint
|
|
valu = workingWord >>> (32 - bits); // :uint
|
|
// if size > 31, handle error
|
|
workingBitsAvailable -= bits;
|
|
if (workingBitsAvailable > 0) {
|
|
workingWord <<= bits;
|
|
} else if (workingBytesAvailable > 0) {
|
|
this.loadWord();
|
|
}
|
|
|
|
bits = size - bits;
|
|
if (bits > 0) {
|
|
return valu << bits | this.readBits(bits);
|
|
} else {
|
|
return valu;
|
|
}
|
|
};
|
|
|
|
// ():uint
|
|
this.skipLeadingZeros = function() {
|
|
var leadingZeroCount; // :uint
|
|
for (leadingZeroCount = 0 ; leadingZeroCount < workingBitsAvailable ; ++leadingZeroCount) {
|
|
if (0 !== (workingWord & (0x80000000 >>> leadingZeroCount))) {
|
|
// the first bit of working word is 1
|
|
workingWord <<= leadingZeroCount;
|
|
workingBitsAvailable -= leadingZeroCount;
|
|
return leadingZeroCount;
|
|
}
|
|
}
|
|
|
|
// we exhausted workingWord and still have not found a 1
|
|
this.loadWord();
|
|
return leadingZeroCount + this.skipLeadingZeros();
|
|
};
|
|
|
|
// ():void
|
|
this.skipUnsignedExpGolomb = function() {
|
|
this.skipBits(1 + this.skipLeadingZeros());
|
|
};
|
|
|
|
// ():void
|
|
this.skipExpGolomb = function() {
|
|
this.skipBits(1 + this.skipLeadingZeros());
|
|
};
|
|
|
|
// ():uint
|
|
this.readUnsignedExpGolomb = function() {
|
|
var clz = this.skipLeadingZeros(); // :uint
|
|
return this.readBits(clz + 1) - 1;
|
|
};
|
|
|
|
// ():int
|
|
this.readExpGolomb = function() {
|
|
var valu = this.readUnsignedExpGolomb(); // :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
|
|
this.readBoolean = function() {
|
|
return 1 === this.readBits(1);
|
|
};
|
|
|
|
// ():int
|
|
this.readUnsignedByte = function() {
|
|
return this.readBits(8);
|
|
};
|
|
|
|
this.loadWord();
|
|
};
|
|
|
|
module.exports = ExpGolomb;
|
|
|
|
},{}],55:[function(require,module,exports){
|
|
/**
|
|
* mux.js
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* All rights reserved.
|
|
*
|
|
* A lightweight readable stream implemention that handles event dispatching.
|
|
* Objects that inherit from streams should call init in their constructors.
|
|
*/
|
|
'use strict';
|
|
|
|
var Stream = function() {
|
|
this.init = function() {
|
|
var listeners = {};
|
|
/**
|
|
* Add a listener for a specified event type.
|
|
* @param type {string} the event name
|
|
* @param listener {function} the callback to be invoked when an event of
|
|
* the specified type occurs
|
|
*/
|
|
this.on = function(type, listener) {
|
|
if (!listeners[type]) {
|
|
listeners[type] = [];
|
|
}
|
|
listeners[type].push(listener);
|
|
};
|
|
/**
|
|
* Remove a listener for a specified event type.
|
|
* @param type {string} the event name
|
|
* @param listener {function} a function previously registered for this
|
|
* type of event through `on`
|
|
*/
|
|
this.off = function(type, listener) {
|
|
var index;
|
|
if (!listeners[type]) {
|
|
return false;
|
|
}
|
|
index = listeners[type].indexOf(listener);
|
|
listeners[type].splice(index, 1);
|
|
return index > -1;
|
|
};
|
|
/**
|
|
* Trigger an event of the specified type on this stream. Any additional
|
|
* arguments to this function are passed as parameters to event listeners.
|
|
* @param type {string} the event name
|
|
*/
|
|
this.trigger = function(type) {
|
|
var callbacks, i, length, args;
|
|
callbacks = listeners[type];
|
|
if (!callbacks) {
|
|
return;
|
|
}
|
|
// Slicing the arguments on every invocation of this method
|
|
// can add a significant amount of overhead. Avoid the
|
|
// intermediate object creation for the common case of a
|
|
// single callback argument
|
|
if (arguments.length === 2) {
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].call(this, arguments[1]);
|
|
}
|
|
} else {
|
|
args = [];
|
|
i = arguments.length;
|
|
for (i = 1; i < arguments.length; ++i) {
|
|
args.push(arguments[i]);
|
|
}
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* Destroys the stream and cleans up.
|
|
*/
|
|
this.dispose = function() {
|
|
listeners = {};
|
|
};
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Forwards all `data` events on this stream to the destination stream. The
|
|
* destination stream should provide a method `push` to receive the data
|
|
* events as they arrive.
|
|
* @param destination {stream} the stream that will receive all `data` events
|
|
* @param autoFlush {boolean} if false, we will not call `flush` on the destination
|
|
* when the current stream emits a 'done' event
|
|
* @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
|
|
*/
|
|
Stream.prototype.pipe = function(destination) {
|
|
this.on('data', function(data) {
|
|
destination.push(data);
|
|
});
|
|
|
|
this.on('done', function(flushSource) {
|
|
destination.flush(flushSource);
|
|
});
|
|
|
|
return destination;
|
|
};
|
|
|
|
// Default stream functions that are expected to be overridden to perform
|
|
// actual work. These are provided by the prototype as a sort of no-op
|
|
// implementation so that we don't have to check for their existence in the
|
|
// `pipe` function above.
|
|
Stream.prototype.push = function(data) {
|
|
this.trigger('data', data);
|
|
};
|
|
|
|
Stream.prototype.flush = function(flushSource) {
|
|
this.trigger('done', flushSource);
|
|
};
|
|
|
|
module.exports = Stream;
|
|
|
|
},{}],56:[function(require,module,exports){
|
|
var bundleFn = arguments[3];
|
|
var sources = arguments[4];
|
|
var cache = arguments[5];
|
|
|
|
var stringify = JSON.stringify;
|
|
|
|
module.exports = function (fn) {
|
|
var keys = [];
|
|
var wkey;
|
|
var cacheKeys = Object.keys(cache);
|
|
|
|
for (var i = 0, l = cacheKeys.length; i < l; i++) {
|
|
var key = cacheKeys[i];
|
|
if (cache[key].exports === fn) {
|
|
wkey = key;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!wkey) {
|
|
wkey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);
|
|
var wcache = {};
|
|
for (var i = 0, l = cacheKeys.length; i < l; i++) {
|
|
var key = cacheKeys[i];
|
|
wcache[key] = key;
|
|
}
|
|
sources[wkey] = [
|
|
Function(['require','module','exports'], '(' + fn + ')(self)'),
|
|
wcache
|
|
];
|
|
}
|
|
var skey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);
|
|
|
|
var scache = {}; scache[wkey] = wkey;
|
|
sources[skey] = [
|
|
Function(['require'],'require(' + stringify(wkey) + ')(self)'),
|
|
scache
|
|
];
|
|
|
|
var src = '(' + bundleFn + ')({'
|
|
+ Object.keys(sources).map(function (key) {
|
|
return stringify(key) + ':['
|
|
+ sources[key][0]
|
|
+ ',' + stringify(sources[key][1]) + ']'
|
|
;
|
|
}).join(',')
|
|
+ '},{},[' + stringify(skey) + '])'
|
|
;
|
|
|
|
var URL = window.URL || window.webkitURL || window.mozURL || window.msURL;
|
|
|
|
return new Worker(URL.createObjectURL(
|
|
new Blob([src], { type: 'text/javascript' })
|
|
));
|
|
};
|
|
|
|
},{}],57:[function(require,module,exports){
|
|
(function (global){
|
|
/**
|
|
* @file videojs-contrib-hls.js
|
|
*
|
|
* The main file for the HLS project.
|
|
* License: https://github.com/videojs/videojs-contrib-hls/blob/master/LICENSE
|
|
*/
|
|
'use strict';
|
|
|
|
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 _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
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 _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 _globalDocument = require('global/document');
|
|
|
|
var _globalDocument2 = _interopRequireDefault(_globalDocument);
|
|
|
|
var _playlistLoader = require('./playlist-loader');
|
|
|
|
var _playlistLoader2 = _interopRequireDefault(_playlistLoader);
|
|
|
|
var _playlist = require('./playlist');
|
|
|
|
var _playlist2 = _interopRequireDefault(_playlist);
|
|
|
|
var _xhr = require('./xhr');
|
|
|
|
var _xhr2 = _interopRequireDefault(_xhr);
|
|
|
|
var _decrypter = require('./decrypter');
|
|
|
|
var _binUtils = require('./bin-utils');
|
|
|
|
var _binUtils2 = _interopRequireDefault(_binUtils);
|
|
|
|
var _videojsContribMediaSources = require('videojs-contrib-media-sources');
|
|
|
|
var _m3u8 = require('./m3u8');
|
|
|
|
var _m3u82 = _interopRequireDefault(_m3u8);
|
|
|
|
var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
|
|
|
|
var _videoJs2 = _interopRequireDefault(_videoJs);
|
|
|
|
var _masterPlaylistController = require('./master-playlist-controller');
|
|
|
|
var _masterPlaylistController2 = _interopRequireDefault(_masterPlaylistController);
|
|
|
|
/**
|
|
* determine if an object a is differnt from
|
|
* and object b. both only having one dimensional
|
|
* properties
|
|
*
|
|
* @param {Object} a object one
|
|
* @param {Object} b object two
|
|
* @return {Boolean} if the object has changed or not
|
|
*/
|
|
var objectChanged = function objectChanged(a, b) {
|
|
if (typeof a !== typeof b) {
|
|
return true;
|
|
}
|
|
// if we have a different number of elements
|
|
// something has changed
|
|
if (Object.keys(a).length !== Object.keys(b).length) {
|
|
return true;
|
|
}
|
|
|
|
for (var prop in a) {
|
|
if (!b[prop] || a[prop] !== b[prop]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
var Hls = {
|
|
PlaylistLoader: _playlistLoader2['default'],
|
|
Playlist: _playlist2['default'],
|
|
Decrypter: _decrypter.Decrypter,
|
|
AsyncStream: _decrypter.AsyncStream,
|
|
decrypt: _decrypter.decrypt,
|
|
utils: _binUtils2['default'],
|
|
xhr: (0, _xhr2['default'])()
|
|
};
|
|
|
|
// the desired length of video to maintain in the buffer, in seconds
|
|
Hls.GOAL_BUFFER_LENGTH = 30;
|
|
|
|
// A fudge factor to apply to advertised playlist bitrates to account for
|
|
// temporary flucations in client bandwidth
|
|
var BANDWIDTH_VARIANCE = 1.2;
|
|
|
|
/**
|
|
* Returns the CSS value for the specified property on an element
|
|
* using `getComputedStyle`. Firefox has a long-standing issue where
|
|
* getComputedStyle() may return null when running in an iframe with
|
|
* `display: none`.
|
|
*
|
|
* @see https://bugzilla.mozilla.org/show_bug.cgi?id=548397
|
|
* @param {HTMLElement} el the htmlelement to work on
|
|
* @param {string} the proprety to get the style for
|
|
*/
|
|
var safeGetComputedStyle = function safeGetComputedStyle(el, property) {
|
|
var result = undefined;
|
|
|
|
if (!el) {
|
|
return '';
|
|
}
|
|
|
|
result = getComputedStyle(el);
|
|
if (!result) {
|
|
return '';
|
|
}
|
|
|
|
return result[property];
|
|
};
|
|
|
|
/**
|
|
* Chooses the appropriate media playlist based on the current
|
|
* bandwidth estimate and the player size.
|
|
*
|
|
* @return {Playlist} the highest bitrate playlist less than the currently detected
|
|
* bandwidth, accounting for some amount of bandwidth variance
|
|
*/
|
|
Hls.STANDARD_PLAYLIST_SELECTOR = function () {
|
|
var effectiveBitrate = undefined;
|
|
var sortedPlaylists = this.playlists.master.playlists.slice();
|
|
var bandwidthPlaylists = [];
|
|
var now = +new Date();
|
|
var i = undefined;
|
|
var variant = undefined;
|
|
var bandwidthBestVariant = undefined;
|
|
var resolutionPlusOne = undefined;
|
|
var resolutionPlusOneAttribute = undefined;
|
|
var resolutionBestVariant = undefined;
|
|
var width = undefined;
|
|
var height = undefined;
|
|
|
|
sortedPlaylists.sort(Hls.comparePlaylistBandwidth);
|
|
|
|
// filter out any playlists that have been excluded due to
|
|
// incompatible configurations or playback errors
|
|
sortedPlaylists = sortedPlaylists.filter(function (localVariant) {
|
|
if (typeof localVariant.excludeUntil !== 'undefined') {
|
|
return now >= localVariant.excludeUntil;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
// filter out any variant that has greater effective bitrate
|
|
// than the current estimated bandwidth
|
|
i = sortedPlaylists.length;
|
|
while (i--) {
|
|
variant = sortedPlaylists[i];
|
|
|
|
// ignore playlists without bandwidth information
|
|
if (!variant.attributes || !variant.attributes.BANDWIDTH) {
|
|
continue;
|
|
}
|
|
|
|
effectiveBitrate = variant.attributes.BANDWIDTH * BANDWIDTH_VARIANCE;
|
|
|
|
if (effectiveBitrate < this.bandwidth) {
|
|
bandwidthPlaylists.push(variant);
|
|
|
|
// since the playlists are sorted in ascending order by
|
|
// bandwidth, the first viable variant is the best
|
|
if (!bandwidthBestVariant) {
|
|
bandwidthBestVariant = variant;
|
|
}
|
|
}
|
|
}
|
|
|
|
i = bandwidthPlaylists.length;
|
|
|
|
// sort variants by resolution
|
|
bandwidthPlaylists.sort(Hls.comparePlaylistResolution);
|
|
|
|
// forget our old variant from above,
|
|
// or we might choose that in high-bandwidth scenarios
|
|
// (this could be the lowest bitrate rendition as we go through all of them above)
|
|
variant = null;
|
|
|
|
width = parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10);
|
|
height = parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10);
|
|
|
|
// iterate through the bandwidth-filtered playlists and find
|
|
// best rendition by player dimension
|
|
while (i--) {
|
|
variant = bandwidthPlaylists[i];
|
|
|
|
// ignore playlists without resolution information
|
|
if (!variant.attributes || !variant.attributes.RESOLUTION || !variant.attributes.RESOLUTION.width || !variant.attributes.RESOLUTION.height) {
|
|
continue;
|
|
}
|
|
|
|
// since the playlists are sorted, the first variant that has
|
|
// dimensions less than or equal to the player size is the best
|
|
var variantResolution = variant.attributes.RESOLUTION;
|
|
|
|
if (variantResolution.width === width && variantResolution.height === height) {
|
|
// if we have the exact resolution as the player use it
|
|
resolutionPlusOne = null;
|
|
resolutionBestVariant = variant;
|
|
break;
|
|
} else if (variantResolution.width < width && variantResolution.height < height) {
|
|
// if both dimensions are less than the player use the
|
|
// previous (next-largest) variant
|
|
break;
|
|
} else if (!resolutionPlusOne || variantResolution.width < resolutionPlusOneAttribute.width && variantResolution.height < resolutionPlusOneAttribute.height) {
|
|
// If we still haven't found a good match keep a
|
|
// reference to the previous variant for the next loop
|
|
// iteration
|
|
|
|
// By only saving variants if they are smaller than the
|
|
// previously saved variant, we ensure that we also pick
|
|
// the highest bandwidth variant that is just-larger-than
|
|
// the video player
|
|
resolutionPlusOne = variant;
|
|
resolutionPlusOneAttribute = resolutionPlusOne.attributes.RESOLUTION;
|
|
}
|
|
}
|
|
|
|
// fallback chain of variants
|
|
return resolutionPlusOne || resolutionBestVariant || bandwidthBestVariant || sortedPlaylists[0];
|
|
};
|
|
|
|
// HLS is a source handler, not a tech. Make sure attempts to use it
|
|
// as one do not cause exceptions.
|
|
Hls.canPlaySource = function () {
|
|
return _videoJs2['default'].log.warn('HLS is no longer a tech. Please remove it from ' + 'your player\'s techOrder.');
|
|
};
|
|
|
|
/**
|
|
* Whether the browser has built-in HLS support.
|
|
*/
|
|
Hls.supportsNativeHls = (function () {
|
|
var video = _globalDocument2['default'].createElement('video');
|
|
|
|
// native HLS is definitely not supported if HTML5 video isn't
|
|
if (!_videoJs2['default'].getComponent('Html5').isSupported()) {
|
|
return false;
|
|
}
|
|
|
|
// HLS manifests can go by many mime-types
|
|
var canPlay = [
|
|
// Apple santioned
|
|
'application/vnd.apple.mpegurl',
|
|
// Apple sanctioned for backwards compatibility
|
|
'audio/mpegurl',
|
|
// Very common
|
|
'audio/x-mpegurl',
|
|
// Very common
|
|
'application/x-mpegurl',
|
|
// Included for completeness
|
|
'video/x-mpegurl', 'video/mpegurl', 'application/mpegurl'];
|
|
|
|
return canPlay.some(function (canItPlay) {
|
|
return (/maybe|probably/i.test(video.canPlayType(canItPlay))
|
|
);
|
|
});
|
|
})();
|
|
|
|
/**
|
|
* HLS is a source handler, not a tech. Make sure attempts to use it
|
|
* as one do not cause exceptions.
|
|
*/
|
|
Hls.isSupported = function () {
|
|
return _videoJs2['default'].log.warn('HLS is no longer a tech. Please remove it from ' + 'your player\'s techOrder.');
|
|
};
|
|
|
|
var Component = _videoJs2['default'].getComponent('Component');
|
|
|
|
/**
|
|
* The Hls Handler object, where we orchestrate all of the parts
|
|
* of HLS to interact with video.js
|
|
*
|
|
* @class HlsHandler
|
|
* @extends videojs.Component
|
|
* @param {Object} source the soruce object
|
|
* @param {Tech} tech the parent tech object
|
|
* @param {Object} options optional and required options
|
|
*/
|
|
|
|
var HlsHandler = (function (_Component) {
|
|
_inherits(HlsHandler, _Component);
|
|
|
|
function HlsHandler(source, tech, options) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, HlsHandler);
|
|
|
|
_get(Object.getPrototypeOf(HlsHandler.prototype), 'constructor', this).call(this, tech);
|
|
|
|
// tech.player() is deprecated but setup a reference to HLS for
|
|
// backwards-compatibility
|
|
if (tech.options_ && tech.options_.playerId) {
|
|
var _player = (0, _videoJs2['default'])(tech.options_.playerId);
|
|
|
|
if (!_player.hasOwnProperty('hls')) {
|
|
Object.defineProperty(_player, 'hls', {
|
|
get: function get() {
|
|
_videoJs2['default'].log.warn('player.hls is deprecated. Use player.tech.hls instead.');
|
|
return _this;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
this.options_ = _videoJs2['default'].mergeOptions(_videoJs2['default'].options.hls || {}, options.hls);
|
|
this.tech_ = tech;
|
|
this.source_ = source;
|
|
|
|
// start playlist selection at a reasonable bandwidth for
|
|
// broadband internet
|
|
// 0.5 Mbps
|
|
this.bandwidth = this.options_.bandwidth || 4194304;
|
|
this.bytesReceived = 0;
|
|
|
|
// listen for fullscreenchange events for this player so that we
|
|
// can adjust our quality selection quickly
|
|
this.on(_globalDocument2['default'], ['fullscreenchange', 'webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'], function (event) {
|
|
var fullscreenElement = _globalDocument2['default'].fullscreenElement || _globalDocument2['default'].webkitFullscreenElement || _globalDocument2['default'].mozFullScreenElement || _globalDocument2['default'].msFullscreenElement;
|
|
|
|
if (fullscreenElement && fullscreenElement.contains(_this.tech_.el())) {
|
|
_this.masterPlaylistController_.fastQualityChange_();
|
|
}
|
|
});
|
|
|
|
this.on(this.tech_, 'seeking', function () {
|
|
this.setCurrentTime(this.tech_.currentTime());
|
|
});
|
|
this.on(this.tech_, 'error', function () {
|
|
if (this.masterPlaylistController_) {
|
|
this.masterPlaylistController_.pauseLoading();
|
|
}
|
|
});
|
|
|
|
this.audioTrackChange_ = function () {
|
|
_this.masterPlaylistController_.useAudio();
|
|
};
|
|
|
|
this.on(this.tech_, 'play', this.play);
|
|
}
|
|
|
|
/**
|
|
* The Source Handler object, which informs video.js what additional
|
|
* MIME types are supported and sets up playback. It is registered
|
|
* automatically to the appropriate tech based on the capabilities of
|
|
* the browser it is running in. It is not necessary to use or modify
|
|
* this object in normal usage.
|
|
*/
|
|
|
|
/**
|
|
* called when player.src gets called, handle a new source
|
|
*
|
|
* @param {Object} src the source object to handle
|
|
*/
|
|
|
|
_createClass(HlsHandler, [{
|
|
key: 'src',
|
|
value: function src(_src) {
|
|
var _this2 = this;
|
|
|
|
// do nothing if the src is falsey
|
|
if (!_src) {
|
|
return;
|
|
}
|
|
|
|
['withCredentials', 'bandwidth'].forEach(function (option) {
|
|
if (typeof _this2.source_[option] !== 'undefined') {
|
|
_this2.options_[option] = _this2.source_[option];
|
|
}
|
|
});
|
|
this.options_.url = this.source_.src;
|
|
this.options_.tech = this.tech_;
|
|
this.options_.externHls = Hls;
|
|
this.options_.bandwidth = this.bandwidth;
|
|
this.masterPlaylistController_ = new _masterPlaylistController2['default'](this.options_);
|
|
// `this` in selectPlaylist should be the HlsHandler for backwards
|
|
// compatibility with < v2
|
|
this.masterPlaylistController_.selectPlaylist = Hls.STANDARD_PLAYLIST_SELECTOR.bind(this);
|
|
|
|
// re-expose some internal objects for backwards compatibility with < v2
|
|
this.playlists = this.masterPlaylistController_.masterPlaylistLoader_;
|
|
this.mediaSource = this.masterPlaylistController_.mediaSource;
|
|
|
|
// Proxy assignment of some properties to the master playlist
|
|
// controller. Using a custom property for backwards compatibility
|
|
// with < v2
|
|
Object.defineProperties(this, {
|
|
selectPlaylist: {
|
|
get: function get() {
|
|
return this.masterPlaylistController_.selectPlaylist;
|
|
},
|
|
set: function set(selectPlaylist) {
|
|
this.masterPlaylistController_.selectPlaylist = selectPlaylist.bind(this);
|
|
}
|
|
},
|
|
bandwidth: {
|
|
get: function get() {
|
|
return this.masterPlaylistController_.mainSegmentLoader_.bandwidth;
|
|
},
|
|
set: function set(bandwidth) {
|
|
this.masterPlaylistController_.mainSegmentLoader_.bandwidth = bandwidth;
|
|
}
|
|
}
|
|
});
|
|
|
|
this.tech_.one('canplay', this.masterPlaylistController_.setupFirstPlay.bind(this.masterPlaylistController_));
|
|
|
|
this.masterPlaylistController_.on('sourceopen', function () {
|
|
_this2.tech_.audioTracks().addEventListener('change', _this2.audioTrackChange_);
|
|
});
|
|
|
|
this.masterPlaylistController_.on('audioinfo', function (e) {
|
|
if (!_videoJs2['default'].browser.IS_FIREFOX || !_this2.audioInfo_ || !objectChanged(_this2.audioInfo_, e.info)) {
|
|
_this2.audioInfo_ = e.info;
|
|
return;
|
|
}
|
|
|
|
var error = 'had different audio properties (channels, sample rate, etc.) ' + 'or changed in some other way. This behavior is currently ' + 'unsupported in Firefox due to an issue: \n\n' + 'https://bugzilla.mozilla.org/show_bug.cgi?id=1247138\n\n';
|
|
|
|
var enabledTrack = undefined;
|
|
var defaultTrack = undefined;
|
|
|
|
_this2.masterPlaylistController_.audioTracks_.forEach(function (t) {
|
|
if (!defaultTrack && t['default']) {
|
|
defaultTrack = t;
|
|
}
|
|
|
|
if (!enabledTrack && t.enabled) {
|
|
enabledTrack = t;
|
|
}
|
|
});
|
|
|
|
// they did not switch audiotracks
|
|
// blacklist the current playlist
|
|
if (!enabledTrack.getLoader(_this2.activeAudioGroup_())) {
|
|
error = 'The rendition that we tried to switch to ' + error + 'Unfortunately that means we will have to blacklist ' + 'the current playlist and switch to another. Sorry!';
|
|
_this2.masterPlaylistController_.blacklistCurrentPlaylist();
|
|
} else {
|
|
error = 'The audio track \'' + enabledTrack.label + '\' that we tried to ' + ('switch to ' + error + ' Unfortunately this means we will have to ') + ('return you to the main track \'' + defaultTrack.label + '\'. Sorry!');
|
|
defaultTrack.enabled = true;
|
|
_this2.tech_.audioTracks().removeTrack(enabledTrack);
|
|
}
|
|
|
|
_videoJs2['default'].log.warn(error);
|
|
_this2.masterPlaylistController_.useAudio();
|
|
});
|
|
this.masterPlaylistController_.on('selectedinitialmedia', function () {
|
|
// clear current audioTracks
|
|
_this2.tech_.clearTracks('audio');
|
|
_this2.masterPlaylistController_.audioTracks_.forEach(function (track) {
|
|
_this2.tech_.audioTracks().addTrack(track);
|
|
});
|
|
});
|
|
|
|
// the bandwidth of the primary segment loader is our best
|
|
// estimate of overall bandwidth
|
|
this.on(this.masterPlaylistController_, 'progress', function () {
|
|
this.bandwidth = this.masterPlaylistController_.mainSegmentLoader_.bandwidth;
|
|
this.tech_.trigger('progress');
|
|
});
|
|
|
|
// do nothing if the tech has been disposed already
|
|
// this can occur if someone sets the src in player.ready(), for instance
|
|
if (!this.tech_.el()) {
|
|
return;
|
|
}
|
|
|
|
this.tech_.src(_videoJs2['default'].URL.createObjectURL(this.masterPlaylistController_.mediaSource));
|
|
}
|
|
|
|
/**
|
|
* a helper for grabbing the active audio group from MasterPlaylistController
|
|
*
|
|
* @private
|
|
*/
|
|
}, {
|
|
key: 'activeAudioGroup_',
|
|
value: function activeAudioGroup_() {
|
|
return this.masterPlaylistController_.activeAudioGroup();
|
|
}
|
|
|
|
/**
|
|
* Begin playing the video.
|
|
*/
|
|
}, {
|
|
key: 'play',
|
|
value: function play() {
|
|
this.masterPlaylistController_.play();
|
|
}
|
|
|
|
/**
|
|
* a wrapper around the function in MasterPlaylistController
|
|
*/
|
|
}, {
|
|
key: 'setCurrentTime',
|
|
value: function setCurrentTime(currentTime) {
|
|
this.masterPlaylistController_.setCurrentTime(currentTime);
|
|
}
|
|
|
|
/**
|
|
* a wrapper around the function in MasterPlaylistController
|
|
*/
|
|
}, {
|
|
key: 'duration',
|
|
value: function duration() {
|
|
return this.masterPlaylistController_.duration();
|
|
}
|
|
|
|
/**
|
|
* a wrapper around the function in MasterPlaylistController
|
|
*/
|
|
}, {
|
|
key: 'seekable',
|
|
value: function seekable() {
|
|
return this.masterPlaylistController_.seekable();
|
|
}
|
|
|
|
/**
|
|
* Abort all outstanding work and cleanup.
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
if (this.masterPlaylistController_) {
|
|
this.masterPlaylistController_.dispose();
|
|
}
|
|
this.tech_.audioTracks().removeEventListener('change', this.audioTrackChange_);
|
|
|
|
_get(Object.getPrototypeOf(HlsHandler.prototype), 'dispose', this).call(this);
|
|
}
|
|
}]);
|
|
|
|
return HlsHandler;
|
|
})(Component);
|
|
|
|
var HlsSourceHandler = function HlsSourceHandler(mode) {
|
|
return {
|
|
canHandleSource: function canHandleSource(srcObj) {
|
|
// this forces video.js to skip this tech/mode if its not the one we have been
|
|
// overriden to use, by returing that we cannot handle the source.
|
|
if (_videoJs2['default'].options.hls && _videoJs2['default'].options.hls.mode && _videoJs2['default'].options.hls.mode !== mode) {
|
|
return false;
|
|
}
|
|
return HlsSourceHandler.canPlayType(srcObj.type);
|
|
},
|
|
handleSource: function handleSource(source, tech, options) {
|
|
if (mode === 'flash') {
|
|
// We need to trigger this asynchronously to give others the chance
|
|
// to bind to the event when a source is set at player creation
|
|
tech.setTimeout(function () {
|
|
tech.trigger('loadstart');
|
|
}, 1);
|
|
}
|
|
|
|
var settings = _videoJs2['default'].mergeOptions(options, { hls: { mode: mode } });
|
|
|
|
tech.hls = new HlsHandler(source, tech, settings);
|
|
|
|
tech.hls.xhr = (0, _xhr2['default'])();
|
|
// Use a global `before` function if specified on videojs.Hls.xhr
|
|
// but still allow for a per-player override
|
|
if (_videoJs2['default'].Hls.xhr.beforeRequest) {
|
|
tech.hls.xhr.beforeRequest = _videoJs2['default'].Hls.xhr.beforeRequest;
|
|
}
|
|
|
|
tech.hls.src(source.src);
|
|
return tech.hls;
|
|
},
|
|
canPlayType: function canPlayType(type) {
|
|
if (HlsSourceHandler.canPlayType(type)) {
|
|
return 'maybe';
|
|
}
|
|
return '';
|
|
}
|
|
};
|
|
};
|
|
|
|
/**
|
|
* A comparator function to sort two playlist object by bandwidth.
|
|
*
|
|
* @param {Object} left a media playlist object
|
|
* @param {Object} right a media playlist object
|
|
* @return {Number} Greater than zero if the bandwidth attribute of
|
|
* left is greater than the corresponding attribute of right. Less
|
|
* than zero if the bandwidth of right is greater than left and
|
|
* exactly zero if the two are equal.
|
|
*/
|
|
Hls.comparePlaylistBandwidth = function (left, right) {
|
|
var leftBandwidth = undefined;
|
|
var rightBandwidth = undefined;
|
|
|
|
if (left.attributes && left.attributes.BANDWIDTH) {
|
|
leftBandwidth = left.attributes.BANDWIDTH;
|
|
}
|
|
leftBandwidth = leftBandwidth || window.Number.MAX_VALUE;
|
|
if (right.attributes && right.attributes.BANDWIDTH) {
|
|
rightBandwidth = right.attributes.BANDWIDTH;
|
|
}
|
|
rightBandwidth = rightBandwidth || window.Number.MAX_VALUE;
|
|
|
|
return leftBandwidth - rightBandwidth;
|
|
};
|
|
|
|
/**
|
|
* A comparator function to sort two playlist object by resolution (width).
|
|
* @param {Object} left a media playlist object
|
|
* @param {Object} right a media playlist object
|
|
* @return {Number} Greater than zero if the resolution.width attribute of
|
|
* left is greater than the corresponding attribute of right. Less
|
|
* than zero if the resolution.width of right is greater than left and
|
|
* exactly zero if the two are equal.
|
|
*/
|
|
Hls.comparePlaylistResolution = function (left, right) {
|
|
var leftWidth = undefined;
|
|
var rightWidth = undefined;
|
|
|
|
if (left.attributes && left.attributes.RESOLUTION && left.attributes.RESOLUTION.width) {
|
|
leftWidth = left.attributes.RESOLUTION.width;
|
|
}
|
|
|
|
leftWidth = leftWidth || window.Number.MAX_VALUE;
|
|
|
|
if (right.attributes && right.attributes.RESOLUTION && right.attributes.RESOLUTION.width) {
|
|
rightWidth = right.attributes.RESOLUTION.width;
|
|
}
|
|
|
|
rightWidth = rightWidth || window.Number.MAX_VALUE;
|
|
|
|
// NOTE - Fallback to bandwidth sort as appropriate in cases where multiple renditions
|
|
// have the same media dimensions/ resolution
|
|
if (leftWidth === rightWidth && left.attributes.BANDWIDTH && right.attributes.BANDWIDTH) {
|
|
return left.attributes.BANDWIDTH - right.attributes.BANDWIDTH;
|
|
}
|
|
return leftWidth - rightWidth;
|
|
};
|
|
|
|
HlsSourceHandler.canPlayType = function (type) {
|
|
var mpegurlRE = /^(audio|video|application)\/(x-|vnd\.apple\.)?mpegurl/i;
|
|
|
|
// favor native HLS support if it's available
|
|
if (Hls.supportsNativeHls) {
|
|
return false;
|
|
}
|
|
return mpegurlRE.test(type);
|
|
};
|
|
|
|
if (typeof _videoJs2['default'].MediaSource === 'undefined' || typeof _videoJs2['default'].URL === 'undefined') {
|
|
_videoJs2['default'].MediaSource = _videojsContribMediaSources.MediaSource;
|
|
_videoJs2['default'].URL = _videojsContribMediaSources.URL;
|
|
}
|
|
|
|
// register source handlers with the appropriate techs
|
|
if (_videojsContribMediaSources.MediaSource.supportsNativeMediaSources()) {
|
|
_videoJs2['default'].getComponent('Html5').registerSourceHandler(HlsSourceHandler('html5'));
|
|
}
|
|
if (window.Uint8Array) {
|
|
_videoJs2['default'].getComponent('Flash').registerSourceHandler(HlsSourceHandler('flash'));
|
|
}
|
|
|
|
_videoJs2['default'].HlsHandler = HlsHandler;
|
|
_videoJs2['default'].HlsSourceHandler = HlsSourceHandler;
|
|
_videoJs2['default'].Hls = Hls;
|
|
_videoJs2['default'].m3u8 = _m3u82['default'];
|
|
_videoJs2['default'].registerComponent('Hls', Hls);
|
|
_videoJs2['default'].options.hls = _videoJs2['default'].options.hls || {};
|
|
|
|
module.exports = {
|
|
Hls: Hls,
|
|
HlsHandler: HlsHandler,
|
|
HlsSourceHandler: HlsSourceHandler
|
|
};
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./bin-utils":1,"./decrypter":5,"./m3u8":7,"./master-playlist-controller":11,"./playlist":13,"./playlist-loader":12,"./xhr":19,"global/document":21,"videojs-contrib-media-sources":34}]},{},[57])(57)
|
|
});
|