https://www.saalbach.com/cache-buster-1777443972626/static/js/libs/videojs-livestream/videojs-contrib-hls.js

1/**
2 * videojs-contrib-hls
3 * @version 5.11.0
4 * @copyright 2017 Brightcove, Inc
5 * @license Apache-2.0
6 */
7(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){
8/**
9 * @file ad-cue-tags.js
10 */
11'use strict';
12
13Object.defineProperty(exports, '__esModule', {
14  value: true
15});
16
17var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
18
19function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
20
21var _globalWindow = require('global/window');
22
23var _globalWindow2 = _interopRequireDefault(_globalWindow);
24
25/**
26 * Searches for an ad cue that overlaps with the given mediaTime
27 */
28var findAdCue = function findAdCue(track, mediaTime) {
29  var cues = track.cues;
30
31  for (var i = 0; i < cues.length; i++) {
32    var cue = cues[i];
33
34    if (mediaTime >= cue.adStartTime && mediaTime <= cue.adEndTime) {
35      return cue;
36    }
37  }
38  return null;
39};
40
41var updateAdCues = function updateAdCues(media, track) {
42  var offset = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2];
43
44  if (!media.segments) {
45    return;
46  }
47
48  var mediaTime = offset;
49  var cue = undefined;
50
51  for (var i = 0; i < media.segments.length; i++) {
52    var segment = media.segments[i];
53
54    if (!cue) {
55      // Since the cues will span for at least the segment duration, adding a fudge
56      // factor of half segment duration will prevent duplicate cues from being
57      // created when timing info is not exact (e.g. cue start time initialized
58      // at 10.006677, but next call mediaTime is 10.003332 )
59      cue = findAdCue(track, mediaTime + segment.duration / 2);
60    }
61
62    if (cue) {
63      if ('cueIn' in segment) {
64        // Found a CUE-IN so end the cue
65        cue.endTime = mediaTime;
66        cue.adEndTime = mediaTime;
67        mediaTime += segment.duration;
68        cue = null;
69        continue;
70      }
71
72      if (mediaTime < cue.endTime) {
73        // Already processed this mediaTime for this cue
74        mediaTime += segment.duration;
75        continue;
76      }
77
78      // otherwise extend cue until a CUE-IN is found
79      cue.endTime += segment.duration;
80    } else {
81      if ('cueOut' in segment) {
82        cue = new _globalWindow2['default'].VTTCue(mediaTime, mediaTime + segment.duration, segment.cueOut);
83        cue.adStartTime = mediaTime;
84        // Assumes tag format to be
85        // #EXT-X-CUE-OUT:30
86        cue.adEndTime = mediaTime + parseFloat(segment.cueOut);
87        track.addCue(cue);
88      }
89
90      if ('cueOutCont' in segment) {
91        // Entered into the middle of an ad cue
92        var adOffset = undefined;
93        var adTotal = undefined;
94
95        // Assumes tag formate to be
96        // #EXT-X-CUE-OUT-CONT:10/30
97
98        var _segment$cueOutCont$split$map = segment.cueOutCont.split('/').map(parseFloat);
99
100        var _segment$cueOutCont$split$map2 = _slicedToArray(_segment$cueOutCont$split$map, 2);
101
102        adOffset = _segment$cueOutCont$split$map2[0];
103        adTotal = _segment$cueOutCont$split$map2[1];
104
105        cue = new _globalWindow2['default'].VTTCue(mediaTime, mediaTime + segment.duration, '');
106        cue.adStartTime = mediaTime - adOffset;
107        cue.adEndTime = cue.adStartTime + adTotal;
108        track.addCue(cue);
109      }
110    }
111    mediaTime += segment.duration;
112  }
113};
114
115exports['default'] = {
116  updateAdCues: updateAdCues,
117  findAdCue: findAdCue
118};
119module.exports = exports['default'];
120},{"global/window":32}],2:[function(require,module,exports){
121/**
122 * @file bin-utils.js
123 */
124
125/**
126 * convert a TimeRange to text
127 *
128 * @param {TimeRange} range the timerange to use for conversion
129 * @param {Number} i the iterator on the range to convert
130 */
131'use strict';
132
133Object.defineProperty(exports, '__esModule', {
134  value: true
135});
136var textRange = function textRange(range, i) {
137  return range.start(i) + '-' + range.end(i);
138};
139
140/**
141 * format a number as hex string
142 *
143 * @param {Number} e The number
144 * @param {Number} i the iterator
145 */
146var formatHexString = function formatHexString(e, i) {
147  var value = e.toString(16);
148
149  return '00'.substring(0, 2 - value.length) + value + (i % 2 ? ' ' : '');
150};
151var formatAsciiString = function formatAsciiString(e) {
152  if (e >= 0x20 && e < 0x7e) {
153    return String.fromCharCode(e);
154  }
155  return '.';
156};
157
158/**
159 * Creates an object for sending to a web worker modifying properties that are TypedArrays
160 * into a new object with seperated properties for the buffer, byteOffset, and byteLength.
161 *
162 * @param {Object} message
163 *        Object of properties and values to send to the web worker
164 * @return {Object}
165 *         Modified message with TypedArray values expanded
166 * @function createTransferableMessage
167 */
168var createTransferableMessage = function createTransferableMessage(message) {
169  var transferable = {};
170
171  Object.keys(message).forEach(function (key) {
172    var value = message[key];
173
174    if (ArrayBuffer.isView(value)) {
175      transferable[key] = {
176        bytes: value.buffer,
177        byteOffset: value.byteOffset,
178        byteLength: value.byteLength
179      };
180    } else {
181      transferable[key] = value;
182    }
183  });
184
185  return transferable;
186};
187
188/**
189 * Returns a unique string identifier for a media initialization
190 * segment.
191 */
192var initSegmentId = function initSegmentId(initSegment) {
193  var byterange = initSegment.byterange || {
194    length: Infinity,
195    offset: 0
196  };
197
198  return [byterange.length, byterange.offset, initSegment.resolvedUri].join(',');
199};
200
201/**
202 * utils to help dump binary data to the console
203 */
204var utils = {
205  hexDump: function hexDump(data) {
206    var bytes = Array.prototype.slice.call(data);
207    var step = 16;
208    var result = '';
209    var hex = undefined;
210    var ascii = undefined;
211
212    for (var j = 0;

212 j < bytes.length / step; j++) {
213      hex = bytes.slice(j * step, j * step + step).map(formatHexString).join('');
214      ascii = bytes.slice(j * step, j * step + step).map(formatAsciiString).join('');
215      result += hex + ' ' + ascii + '\n';
216    }
217    return result;
218  },
219  tagDump: function tagDump(tag) {
220    return utils.hexDump(tag.bytes);
221  },
222  textRanges: function textRanges(ranges) {
223    var result = '';
224    var i = undefined;
225
226    for (i = 0; i < ranges.length; i++) {
227      result += textRange(ranges, i) + ' ';
228    }
229    return result;
230  },
231  createTransferableMessage: createTransferableMessage,
232  initSegmentId: initSegmentId
233};
234
235exports['default'] = utils;
236module.exports = exports['default'];
237},{}],3:[function(require,module,exports){
238"use strict";
239
240Object.defineProperty(exports, "__esModule", {
241  value: true
242});
243exports["default"] = {
244  GOAL_BUFFER_LENGTH: 30,
245  MAX_GOAL_BUFFER_LENGTH: 60,
246  GOAL_BUFFER_LENGTH_RATE: 1,
247  // A fudge factor to apply to advertised playlist bitrates to account for
248  // temporary flucations in client bandwidth
249  BANDWIDTH_VARIANCE: 1.2,
250  // How much of the buffer must be filled before we consider upswitching
251  BUFFER_LOW_WATER_LINE: 0,
252  MAX_BUFFER_LOW_WATER_LINE: 30,
253  BUFFER_LOW_WATER_LINE_RATE: 1
254};
255module.exports = exports["default"];
256},{}],4:[function(require,module,exports){
257'use strict';
258
259Object.defineProperty(exports, '__esModule', {
260  value: true
261});
262
263function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
264
265var _globalWindow = require('global/window');
266
267var _globalWindow2 = _interopRequireDefault(_globalWindow);
268
269var _aesDecrypter = require('aes-decrypter');
270
271var _binUtils = require('./bin-utils');
272
273/**
274 * Our web worker interface so that things can talk to aes-decrypter
275 * that will be running in a web worker. the scope is passed to this by
276 * webworkify.
277 *
278 * @param {Object} self
279 *        the scope for the web worker
280 */
281var DecrypterWorker = function DecrypterWorker(self) {
282  self.onmessage = function (event) {
283    var data = event.data;
284    var encrypted = new Uint8Array(data.encrypted.bytes, data.encrypted.byteOffset, data.encrypted.byteLength);
285    var key = new Uint32Array(data.key.bytes, data.key.byteOffset, data.key.byteLength / 4);
286    var iv = new Uint32Array(data.iv.bytes, data.iv.byteOffset, data.iv.byteLength / 4);
287
288    /* eslint-disable no-new, handle-callback-err */
289    new _aesDecrypter.Decrypter(encrypted, key, iv, function (err, bytes) {
290      _globalWindow2['default'].postMessage((0, _binUtils.createTransferableMessage)({
291        source: data.source,
292        decrypted: bytes
293      }), [bytes.buffer]);
294    });
295    /* eslint-enable */
296  };
297};
298
299exports['default'] = function (self) {
300  return new DecrypterWorker(self);
301};
302
303module.exports = exports['default'];
304},{"./bin-utils":2,"aes-decrypter":25,"global/window":32}],5:[function(require,module,exports){
305(function (global){
306/**
307 * @file master-playlist-controller.js
308 */
309'use strict';
310
311Object.defineProperty(exports, '__esModule', {
312  value: true
313});
314
315var _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; }; })();
316
317var _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); } } };
318
319function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
320
321function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
322
323function _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, { c

323onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
324
325var _playlistLoader = require('./playlist-loader');
326
327var _playlistLoader2 = _interopRequireDefault(_playlistLoader);
328
329var _segmentLoader = require('./segment-loader');
330
331var _segmentLoader2 = _interopRequireDefault(_segmentLoader);
332
333var _vttSegmentLoader = require('./vtt-segment-loader');
334
335var _vttSegmentLoader2 = _interopRequireDefault(_vttSegmentLoader);
336
337var _ranges = require('./ranges');
338
339var _ranges2 = _interopRequireDefault(_ranges);
340
341var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
342
343var _videoJs2 = _interopRequireDefault(_videoJs);
344
345var _adCueTags = require('./ad-cue-tags');
346
347var _adCueTags2 = _interopRequireDefault(_adCueTags);
348
349var _syncController = require('./sync-controller');
350
351var _syncController2 = _interopRequireDefault(_syncController);
352
353var _videojsContribMediaSourcesEs5CodecUtils = require('videojs-contrib-media-sources/es5/codec-utils');
354
355var _webworkify = require('webworkify');
356
357var _webworkify2 = _interopRequireDefault(_webworkify);
358
359var _decrypterWorker = require('./decrypter-worker');
360
361var _decrypterWorker2 = _interopRequireDefault(_decrypterWorker);
362
363var _config = require('./config');
364
365var _config2 = _interopRequireDefault(_config);
366
367var _utilCodecsJs = require('./util/codecs.js');
368
369var _mediaGroups = require('./media-groups');
370
371var ABORT_EARLY_BLACKLIST_SECONDS = 60 * 2;
372
373var Hls = undefined;
374
375// Default codec parameters if none were provided for video and/or audio
376var defaultCodecs = {
377  videoCodec: 'avc1',
378  videoObjectTypeIndicator: '.4d400d',
379  // AAC-LC
380  audioProfile: '2'
381};
382
383// SegmentLoader stats that need to have each loader's
384// values summed to calculate the final value
385var loaderStats = ['mediaRequests', 'mediaRequestsAborted', 'mediaRequestsTimedout', 'mediaRequestsErrored', 'mediaTransferDuration', 'mediaBytesTransferred'];
386var sumLoaderStat = function sumLoaderStat(stat) {
387  return this.audioSegmentLoader_[stat] + this.mainSegmentLoader_[stat];
388};
389
390/**
391 * Replace codecs in the codec string with the old apple-style `avc1.<dd>.<dd>` to the
392 * standard `avc1.<hhhhhh>`.
393 *
394 * @param codecString {String} the codec string
395 * @return {String} the codec string with old apple-style codecs replaced
396 *
397 * @private
398 */
399var mapLegacyAvcCodecs_ = function mapLegacyAvcCodecs_(codecString) {
400  return codecString.replace(/avc1\.(\d+)\.(\d+)/i, function (match) {
401    return (0, _videojsContribMediaSourcesEs5CodecUtils.translateLegacyCodecs)([match])[0];
402  });
403};
404
405exports.mapLegacyAvcCodecs_ = mapLegacyAvcCodecs_;
406/**
407 * Build a media mime-type string from a set of parameters
408 * @param {String} type either 'audio' or 'video'
409 * @param {String} container either 'mp2t' or 'mp4'
410 * @param {Array} codecs an array of codec strings to add
411 * @return {String} a valid media mime-type
412 */
413var makeMimeTypeString = function makeMimeTypeString(type, container, codecs) {
414  // The codecs array is filtered so that falsey values are
415  // dropped and don't cause Array#join to create spurious
416  // commas
417  return type + '/' + container + '; codecs="' + codecs.filter(function (c) {
418    return !!c;
419  }).join(', ') + '"';
420};
421
422/**
423 * Returns the type container based on information in the playlist
424 * @param {Playlist} media the current media playlist
425 * @return {String} a valid media container type
426 */
427var getContainerType = function getContainerType(media) {
428  // An initialization segment means the media playlist is an iframe
429  // playlist or is using the mp4 container. We don't currently
430  // support iframe playlists, so assume this is signalling mp4
431  // fragments.
432  if (media.segments && media.segments.length && media.segments[0].map) {
433    return 'mp4';
434  }
435  return 'mp2t';
436};
437
438/**
439 * Returns a set of codec strings parsed from the playlist or the default
440 * codec strings if no codecs were specified in the playlist
441 * @param {Playlist} media the current media playlist
442 * @return {Object} an object with the video and audio codecs
443 */
444var getCodecs = function getCodecs(media) {
445  // if the codecs were explicitly specified, use them instead of the
446  // defaults
447  var mediaAttributes = media.attributes || {};
448
449  if (mediaAttributes.CODECS) {
450    return (0, _utilCodecsJs.parseCodecs)(mediaAttributes.CODECS);
451  }
452  return defaultCodecs;
453};
454
455/**

456 * Calculates the MIME type strings for a working configuration of
457 * SourceBuffers to play variant streams in a master playlist. If
458 * there is no possible working configuration, an empty array will be
459 * returned.
460 *
461 * @param master {Object} the m3u8 object for the master playlist
462 * @param media {Object} the m3u8 object for the variant playlist
463 * @return {Array} the MIME type strings. If the array has more than
464 * one entry, the first element should be applied to the video
465 * SourceBuffer and the second to the audio SourceBuffer.
466 *
467 * @private
468 */
469var mimeTypesForPlaylist_ = function mimeTypesForPlaylist_(master, media) {
470  var containerType = getContainerType(media);
471  var codecInfo = getCodecs(media);
472  var mediaAttributes = media.attributes || {};
473  // Default condition for a traditional HLS (no demuxed audio/video)
474  var isMuxed = true;
475  var isMaat = false;
476
477  if (!media) {
478    // Not enough information
479    return [];
480  }
481
482  if (master.mediaGroups.AUDIO && mediaAttributes.AUDIO) {
483    var audioGroup = master.mediaGroups.AUDIO[mediaAttributes.AUDIO];
484
485    // Handle the case where we are in a multiple-audio track scenario
486    if (audioGroup) {
487      isMaat = true;
488      // Start with the everything demuxed then...
489      isMuxed = false;
490      // ...check to see if any audio group tracks are muxed (ie. lacking a uri)
491      for (var groupId in audioGroup) {
492        if (!audioGroup[groupId].uri) {
493          isMuxed = true;
494          break;
495        }
496      }
497    }
498  }
499
500  // HLS with multiple-audio tracks must always get an audio codec.
501  // Put another way, there is no way to have a video-only multiple-audio HLS!
502  if (isMaat && !codecInfo.audioProfile) {
503    _videoJs2['default'].log.warn('Multiple audio tracks present but no audio codec string is specified. ' + 'Attempting to use the default audio codec (mp4a.40.2)');
504    codecInfo.audioProfile = defaultCodecs.audioProfile;
505  }
506
507  // Generate the final codec strings from the codec object generated above
508  var codecStrings = {};
509
510  if (codecInfo.videoCodec) {
511    codecStrings.video = '' + codecInfo.videoCodec + codecInfo.videoObjectTypeIndicator;
512  }
513
514  if (codecInfo.audioProfile) {
515    codecStrings.audio = 'mp4a.40.' + codecInfo.audioProfile;
516  }
517
518  // Finally, make and return an array with proper mime-types depending on
519  // the configuration
520  var justAudio = makeMimeTypeString('audio', containerType, [codecStrings.audio]);
521  var justVideo = makeMimeTypeString('video', containerType, [codecStrings.video]);
522  var bothVideoAudio = makeMimeTypeString('video', containerType, [codecStrings.video, codecStrings.audio]);
523
524  if (isMaat) {
525    if (!isMuxed && codecStrings.video) {
526      return [justVideo, justAudio];
527    }
528    // There exists the possiblity that this will return a `video/container`
529    // mime-type for the first entry in the array even when there is only audio.
530    // This doesn't appear to be a problem and simplifies the code.
531    return [bothVideoAudio, justAudio];
532  }
533
534  // If there is ano video codec at all, always just return a single
535  // audio/<container> mime-type
536  if (!codecStrings.video) {
537    return [justAudio];
538  }
539
540  // When not using separate audio media groups, audio and video is
541  // *always* muxed
542  return [bothVideoAudio];
543};
544
545exports.mimeTypesForPlaylist_ = mimeTypesForPlaylist_;
546/**
547 * the master playlist controller controller all interactons
548 * between playlists and segmentloaders. At this time this mainly
549 * involves a master playlist and a series of audio playlists
550 * if they are available
551 *
552 * @class MasterPlaylistController
553 * @extends videojs.EventTarget
554 */
555
556var MasterPlaylistController = (function (_videojs$EventTarget) {
557  _inherits(MasterPlaylistController, _videojs$EventTarget);
558
559  function MasterPlaylistController(options) {
560    var _this = this;
561
562    _classCallCheck(this, MasterPlaylistController);
563
564    _get(Object.getPrototypeOf(MasterPlaylistController.prototype), 'constructor', this).call(this);
565
566    var url = options.url;
567    var withCredentials = options.withCredentials;
568    var mode = options.mode;
569    var tech = options.tech;
570    var bandwidth = options.bandwidth;
571    var externHls = options.externHls;
572    var useCueTags = options.useCueTags;

573    var blacklistDuration = options.blacklistDuration;
574    var enableLowInitialPlaylist = options.enableLowInitialPlaylist;
575
576    if (!url) {
577      throw new Error('A non-empty playlist URL is required');
578    }
579
580    Hls = externHls;
581
582    this.withCredentials = withCredentials;
583    this.tech_ = tech;
584    this.hls_ = tech.hls;
585    this.mode_ = mode;
586    this.useCueTags_ = useCueTags;
587    this.blacklistDuration = blacklistDuration;
588    this.enableLowInitialPlaylist = enableLowInitialPlaylist;
589    if (this.useCueTags_) {
590      this.cueTagsTrack_ = this.tech_.addTextTrack('metadata', 'ad-cues');
591      this.cueTagsTrack_.inBandMetadataTrackDispatchType = '';
592    }
593
594    this.requestOptions_ = {
595      withCredentials: this.withCredentials,
596      timeout: null
597    };
598
599    this.mediaTypes_ = (0, _mediaGroups.createMediaTypes)();
600
601    this.mediaSource = new _videoJs2['default'].MediaSource({ mode: mode });
602
603    // load the media source into the player
604    this.mediaSource.addEventListener('sourceopen', this.handleSourceOpen_.bind(this));
605
606    this.seekable_ = _videoJs2['default'].createTimeRanges();
607    this.hasPlayed_ = function () {
608      return false;
609    };
610
611    this.syncController_ = new _syncController2['default'](options);
612    this.segmentMetadataTrack_ = tech.addRemoteTextTrack({
613      kind: 'metadata',
614      label: 'segment-metadata'
615    }, false).track;
616
617    this.decrypter_ = (0, _webworkify2['default'])(_decrypterWorker2['default']);
618
619    var segmentLoaderSettings = {
620      hls: this.hls_,
621      mediaSource: this.mediaSource,
622      currentTime: this.tech_.currentTime.bind(this.tech_),
623      seekable: function seekable() {
624        return _this.seekable();
625      },
626      seeking: function seeking() {
627        return _this.tech_.seeking();
628      },
629      duration: function duration() {
630        return _this.mediaSource.duration;
631      },
632      hasPlayed: function hasPlayed() {
633        return _this.hasPlayed_();
634      },
635      goalBufferLength: function goalBufferLength() {
636        return _this.goalBufferLength();
637      },
638      bandwidth: bandwidth,
639      syncController: this.syncController_,
640      decrypter: this.decrypter_
641    };
642
643    // setup playlist loaders
644    this.masterPlaylistLoader_ = new _playlistLoader2['default'](url, this.hls_, this.withCredentials);
645    this.setupMasterPlaylistLoaderListeners_();
646
647    // setup segment loaders
648    // combined audio/video or just video when alternate audio track is selected
649    this.mainSegmentLoader_ = new _segmentLoader2['default'](_videoJs2['default'].mergeOptions(segmentLoaderSettings, {
650      segmentMetadataTrack: this.segmentMetadataTrack_,
651      loaderType: 'main'
652    }), options);
653
654    // alternate audio track
655    this.audioSegmentLoader_ = new _segmentLoader2['default'](_videoJs2['default'].mergeOptions(segmentLoaderSettings, {
656      loaderType: 'audio'
657    }), options);
658
659    this.subtitleSegmentLoader_ = new _vttSegmentLoader2['default'](_videoJs2['default'].mergeOptions(segmentLoaderSettings, {
660      loaderType: 'vtt'
661    }), options);
662
663    this.setupSegmentLoaderListeners_();
664
665    // Create SegmentLoader stat-getters

666    loaderStats.forEach(function (stat) {
667      _this[stat + '_'] = sumLoaderStat.bind(_this, stat);
668    });
669
670    this.masterPlaylistLoader_.load();
671  }
672
673  /**
674   * Register event handlers on the master playlist loader. A helper
675   * function for construction time.
676   *
677   * @private
678   */
679
680  _createClass(MasterPlaylistController, [{
681    key: 'setupMasterPlaylistLoaderListeners_',
682    value: function setupMasterPlaylistLoaderListeners_() {
683      var _this2 = this;
684
685      this.masterPlaylistLoader_.on('loadedmetadata', function () {
686        var media = _this2.masterPlaylistLoader_.media();
687        var requestTimeout = _this2.masterPlaylistLoader_.targetDuration * 1.5 * 1000;
688
689        // If we don't have any more available playlists, we don't want to
690        // timeout the request.
691        if (_this2.masterPlaylistLoader_.isLowestEnabledRendition_()) {
692          _this2.requestOptions_.timeout = 0;
693        } else {
694          _this2.requestOptions_.timeout = requestTimeout;
695        }
696
697        // if this isn't a live video and preload permits, start
698        // downloading segments
699        if (media.endList && _this2.tech_.preload() !== 'none') {
700          _this2.mainSegmentLoader_.playlist(media, _this2.requestOptions_);
701          _this2.mainSegmentLoader_.load();
702        }
703
704        (0, _mediaGroups.setupMediaGroups)({
705          segmentLoaders: {
706            AUDIO: _this2.audioSegmentLoader_,
707            SUBTITLES: _this2.subtitleSegmentLoader_,
708            main: _this2.mainSegmentLoader_
709          },
710          tech: _this2.tech_,
711          requestOptions: _this2.requestOptions_,
712          masterPlaylistLoader: _this2.masterPlaylistLoader_,
713          mode: _this2.mode_,
714          hls: _this2.hls_,
715          master: _this2.master(),
716          mediaTypes: _this2.mediaTypes_,
717          blacklistCurrentPlaylist: _this2.blacklistCurrentPlaylist.bind(_this2)
718        });
719
720        _this2.triggerPresenceUsage_(_this2.master(), media);
721
722        try {
723          _this2.setupSourceBuffers_();
724        } catch (e) {
725          _videoJs2['default'].log.warn('Failed to create SourceBuffers', e);
726          return _this2.mediaSource.endOfStream('decode');
727        }
728        _this2.setupFirstPlay();
729
730        _this2.trigger('selectedinitialmedia');
731      });
732
733      this.masterPlaylistLoader_.on('loadedplaylist', function () {
734        var updatedPlaylist = _this2.masterPlaylistLoader_.media();
735
736        if (!updatedPlaylist) {
737          var selectedMedia = undefined;
738
739          if (_this2.enableLowInitialPlaylist) {
740            selectedMedia = _this2.selectInitialPlaylist();
741          }
742
743          if (!selectedMedia) {
744            selectedMedia = _this2.selectPlaylist();
745          }
746
747          _this2.initialMedia_ = selectedMedia;
748          _this2.masterPlaylistLoader_.media(_this2.initialMedia_);
749          return;
750        }
751
752        if (_this2.useCueTags_) {
753          _this2.updateAdCues_(updatedPlaylist);
754        }
755
756        // TODO: Create a new event on the PlaylistLoader that signals
757        // that the segments have changed in some way and use that to
758        // update the SegmentLoader instead of doing it twice here and
759        // on `mediachange`
760        _this2.mainSegmentLoader_.playlist(updatedPlaylist, _this2.requestOptions_);
761        _this2.updateDuration();
762
763        // If the player isn't paused, ensure that the segment loader is running,
764        // as it is possible that it was temporarily stopped while waiting for
765        // a playlist (e.g., in case the playlist errored and we re-requested it).
766        if (!_this2.tech_.paused()) {
767          _this2.mainSegmentLoader_.load();
768        }
769
770        if (!updatedPlaylist.endList) {
771          (function () {
772            var addSeekableRange = function addSeekableRange() {
773              var seekable = _this2.seekable();
774
775              if (seekable.length !== 0) {
776                _this2.mediaSource.addSeekableRange_(seekable.start(0), seekable.end(0));
777              }
778            };
779
780            if (_this2.duration() !== Infinity) {
781              (function () {
782                var onDurationchange = function onDurationchange() {
783                  if (_this2.duration() === Infinity) {
784                    addSeekableRange();
785                  } else {
786                    _this2.tech_.one('durationchange', onDurationchange);
787                  }
788                };
789
790                _this2.tech_.one('durationchange', onDurationchange);
791              })();
792            } else {
793              addSeekableRange();
794            }
795          })();
796        }
797      });
798
799      this.masterPlaylistLoader_.on('error', function () {
800        _this2.blacklistCurrentPlaylist(_this2.masterPlaylistLoader_.error);
801      });
802
803      this.masterPlaylistLoader_.on('mediachanging', function () {
804        _this2.mainSegmentLoader_.abort();
805        _this2.mainSegmentLoader_.pause();
806      });
807
808      this.masterPlaylistLoader_.on('mediachange', function () {
809        var media = _this2.masterPlaylistLoader_.media();
810        var requestTimeout = _this2.masterPlaylistLoader_.targetDuration * 1.5 * 1000;
811
812        // If we don't have any more available playlists, we don't want to
813        // timeout the request.
814        if (_this2.masterPlaylistLoader_.isLowestEnabledRendition_()) {
815          _this2.requestOptions_.timeout = 0;
816        } else {
817          _this2.requestOptions_.timeout = requestTimeout;
818        }
819
820        // TODO: Create a new event on the PlaylistLoader that signals
821        // that the segments have changed in some way and use that to
822        // update the SegmentLoader instead of doing it twice here and
823        // on `loadedplaylist`
824        _this2.mainSegmentLoader_.playlist(media, _this2.requestOptions_);
825        _this2.mainSegmentLoader_.load();
826
827        _this2.tech_.trigger({
828          type: 'mediachange',
829          bubbles: true
830        });
831      });
832
833      this.masterPlaylistLoader_.on('playlistunchanged', function () {
834        var updatedPlaylist = _this2.masterPlaylistLoader_.media();
835        var playlistOutdated = _this2.stuckAtPlaylistEnd_(updatedPlaylist);
836
837        if (playlistOutdated) {
838          // Playlist has stopped updating and we're stuck at its end. Try to
839          // blacklist it and switch to another playlist in the hope that that
840          // one is updating (and give the player a chance to re-adjust to the
841          // safe live point).
842          _this2.blacklistCurrentPlaylist({
843            message: 'Playlist no longer updating.'
844          });
845          // useful for monitoring QoS
846          _this2.tech_.trigger('playliststuck');
847        }
848      });
849
850      this.masterPlaylistLoader_.on('renditiondisabled', function () {
851        _this2.tech_.trigger({ type: 'usage', name: 'hls-rendition-disabled' });
852      });
853      this.masterPlaylistLoader_.on('renditionenabled', function () {
854        _this2.tech_.trigger({ type: 'usage', name: 'hls-rendition-enabled' });
855      });
856    }
857
858    /**
859     * A helper function for triggerring presence usage events once per source
860     *
861     * @private
862     */
863  }, {
864    key: 'triggerPresenceUsage_',
865    value: function triggerPresenceUsage_(master, media) {
866      var mediaGroups = master.mediaGroups || {};
867      var defaultDemuxed = true;
868      var audioGroupKeys = Object.keys(mediaGroups.AUDIO);
869
870      for (var mediaGroup in mediaGroups.AUDIO) {
871        for (var label in mediaGroups.AUDIO[mediaGroup]) {
872          var properties = mediaGroups.AUDIO[mediaGroup][label];
873
874          if (!properties.uri) {
875            defaultDemuxed = false;

876          }
877        }
878      }
879
880      if (defaultDemuxed) {
881        this.tech_.trigger({ type: 'usage', name: 'hls-demuxed' });
882      }
883
884      if (Object.keys(mediaGroups.SUBTITLES).length) {
885        this.tech_.trigger({ type: 'usage', name: 'hls-webvtt' });
886      }
887
888      if (Hls.Playlist.isAes(media)) {
889        this.tech_.trigger({ type: 'usage', name: 'hls-aes' });
890      }
891
892      if (Hls.Playlist.isFmp4(media)) {
893        this.tech_.trigger({ type: 'usage', name: 'hls-fmp4' });
894      }
895
896      if (audioGroupKeys.length && Object.keys(mediaGroups.AUDIO[audioGroupKeys[0]]).length > 1) {
897        this.tech_.trigger({ type: 'usage', name: 'hls-alternate-audio' });
898      }
899
900      if (this.useCueTags_) {
901        this.tech_.trigger({ type: 'usage', name: 'hls-playlist-cue-tags' });
902      }
903    }
904
905    /**
906     * Register event handlers on the segment loaders. A helper function
907     * for construction time.
908     *
909     * @private
910     */
911  }, {
912    key: 'setupSegmentLoaderListeners_',
913    value: function setupSegmentLoaderListeners_() {
914      var _this3 = this;
915
916      this.mainSegmentLoader_.on('bandwidthupdate', function () {
917        var nextPlaylist = _this3.selectPlaylist();
918        var currentPlaylist = _this3.masterPlaylistLoader_.media();
919        var buffered = _this3.tech_.buffered();
920        var forwardBuffer = buffered.length ? buffered.end(buffered.length - 1) - _this3.tech_.currentTime() : 0;
921
922        var bufferLowWaterLine = _this3.bufferLowWaterLine();
923
924        // If the playlist is live, then we want to not take low water line into account.
925        // This is because in LIVE, the player plays 3 segments from the end of the
926        // playlist, and if `BUFFER_LOW_WATER_LINE` is greater than the duration availble
927        // in those segments, a viewer will never experience a rendition upswitch.
928        if (!currentPlaylist.endList ||
929        // For the same reason as LIVE, we ignore the low water line when the VOD
930        // duration is below the max potential low water line
931        _this3.duration() < _config2['default'].MAX_BUFFER_LOW_WATER_LINE ||
932        // we want to switch down to lower resolutions quickly to continue playback, but
933        nextPlaylist.attributes.BANDWIDTH < currentPlaylist.attributes.BANDWIDTH ||
934        // ensure we have some buffer before we switch up to prevent us running out of
935        // buffer while loading a higher rendition.
936        forwardBuffer >= bufferLowWaterLine) {
937          _this3.masterPlaylistLoader_.media(nextPlaylist);
938        }
939
940        _this3.tech_.trigger('bandwidthupdate');
941      });
942      this.mainSegmentLoader_.on('progress', function () {
943        _this3.trigger('progress');
944      });
945
946      this.mainSegmentLoader_.on('error', function () {
947        _this3.blacklistCurrentPlaylist(_this3.mainSegmentLoader_.error());
948      });
949
950      this.mainSegmentLoader_.on('syncinfoupdate', function () {
951        _this3.onSyncInfoUpdate_();
952      });
953
954      this.mainSegmentLoader_.on('timestampoffset', function () {
955        _this3.tech_.trigger({ type: 'usage', name: 'hls-timestamp-offset' });
956      });
957      this.audioSegmentLoader_.on('syncinfoupdate', function () {
958        _this3.onSyncInfoUpdate_();
959      });
960
961      this.mainSegmentLoader_.on('ended', function () {
962        _this3.onEndOfStream();
963      });
964
965      this.mainSegmentLoader_.on('earlyabort', function () {
966        _this3.blacklistCurrentPlaylist({
967          message: 'Aborted early because there isn\'t enough bandwidth to complete the ' + 'request without rebuffering.'
968        }, ABORT_EARLY_BLACKLIST_SECONDS);
969      });
970
971      this.mainSegmentLoader_.on('reseteverything', function () {
972        _this3.tech_.trigger('hls-reset');
973      });
974
975      this.audioSegmentLoader_.on('ended', function () {
976        _this3.onEndOfStream();
977      });
978    }
979  }, {
980    key: 'mediaSecondsLoaded_',
981    value: function mediaSecondsLoaded_() {
982      return Math.max(this.audioSegmentLoader_.mediaSecondsLoaded + this.mainSegmentLoader_.mediaSecondsLoaded);
983    }
984
985    /**
986     * Call load on our SegmentLoaders
987     */
988  }, {
989    key: 'load',
990    value: function load() {
991      this.mainSegmentLoader_.load();
992      if (this.mediaTypes_.AUDIO.activePlaylistLoader) {
993        this.audioSegmentLoader_.load();
994      }
995      if (this.mediaTypes_.SUBTITLES.activePlaylistLoader) {
996        this.subtitleSegmentLoader_.load();
997      }
998    }
999
1000    /**
1001     * Re-tune playback quality level for the current player
1002     * conditions. This method may perform destructive actions, like
1003     * removing already buffered content, to readjust the currently
1004     * active playlist quickly.
1005     *
1006     * @private
1007     */
1008  }, {
1009    key: 'fastQualityChange_',
1010    value: function fastQualityChange_() {
1011      var media = this.selectPlaylist();
1012
1013      if (media !== this.masterPlaylistLoader_.media()) {
1014        this.masterPlaylistLoader_.media(media);
1015
1016        this.mainSegmentLoader_.resetLoader();
1017        // don't need to reset audio as it is reset when media changes
1018      }
1019    }
1020
1021    /**
1022     * Begin playback.
1023     */
1024  }, {
1025    key: 'play',
1026    value: function play() {
1027      if (this.setupFirstPlay()) {
1028        return;
1029      }
1030
1031      if (this.tech_.ended()) {
1032        this.tech_.setCurrentTime(0);
1033      }
1034
1035      if (this.hasPlayed_()) {
1036        this.load();
1037      }
1038
1039      var seekable = this.tech_.seekable();
1040
1041      // if the viewer has paused and we fell out of the live window,
1042      // seek forward to the live point
1043      if (this.tech_.duration() === Infinity) {
1044        if (this.tech_.currentTime() < seekable.start(0)) {
1045          return this.tech_.setCurrentTime(seekable.end(seekable.length - 1));
1046        }
1047      }
1048    }
1049
1050    /**
1051     * Seek to the latest media position if this is a live video and the
1052     * player and video are loaded and initialized.
1053     */
1054  }, {
1055    key: 'setupFirstPlay',
1056    value: function setupFirstPlay() {
1057      var seekable = undefined;
1058      var media = this.masterPlaylistLoader_.media();
1059
1060      // check that everything is ready to begin buffering in the live
1061      // scenario
1062      // 1) the active media playlist is available
1063      if (media &&
1064      // 2) the player is not paused
1065      !this.tech_.paused() &&
1066      // 3) the player has not started playing
1067      !this.hasPlayed_()) {
1068
1069        // when the video is a live stream
1070        if (!media.endList) {
1071          this.trigger('firstplay');
1072
1073          // seek to the latest media position for live videos
1074          seekable = this.seekable();
1075          if (seekable.length) {
1076            this.tech_.setCurrentTime(seekable.end(0));
1077          }
1078        }
1079        this.hasPlayed_ = function () {
1080          return true;
1081        };
1082        // now that we are ready, load the segment
1083        this.load();
1084        return true;
1085      }
1086      return false;

1087    }
1088
1089    /**
1090     * handle the sourceopen event on the MediaSource
1091     *
1092     * @private
1093     */
1094  }, {
1095    key: 'handleSourceOpen_',
1096    value: function handleSourceOpen_() {
1097      // Only attempt to create the source buffer if none already exist.
1098      // handleSourceOpen is also called when we are "re-opening" a source buffer
1099      // after `endOfStream` has been called (in response to a seek for instance)
1100      try {
1101        this.setupSourceBuffers_();
1102      } catch (e) {
1103        _videoJs2['default'].log.warn('Failed to create Source Buffers', e);
1104        return this.mediaSource.endOfStream('decode');
1105      }
1106
1107      // if autoplay is enabled, begin playback. This is duplicative of
1108      // code in video.js but is required because play() must be invoked
1109      // *after* the media source has opened.
1110      if (this.tech_.autoplay()) {
1111        this.tech_.play();
1112      }
1113
1114      this.trigger('sourceopen');
1115    }
1116
1117    /**
1118     * Calls endOfStream on the media source when all active stream types have called
1119     * endOfStream
1120     *
1121     * @param {string} streamType
1122     *        Stream type of the segment loader that called endOfStream
1123     * @private
1124     */
1125  }, {
1126    key: 'onEndOfStream',
1127    value: function onEndOfStream() {
1128      var isEndOfStream = this.mainSegmentLoader_.ended_;
1129
1130      if (this.mediaTypes_.AUDIO.activePlaylistLoader) {
1131        // if the audio playlist loader exists, then alternate audio is active, so we need
1132        // to wait for both the main and audio segment loaders to call endOfStream
1133        isEndOfStream = isEndOfStream && this.audioSegmentLoader_.ended_;
1134      }
1135
1136      if (isEndOfStream) {
1137        this.mediaSource.endOfStream();
1138      }
1139    }
1140
1141    /**
1142     * Check if a playlist has stopped being updated
1143     * @param {Object} playlist the media playlist object
1144     * @return {boolean} whether the playlist has stopped being updated or not
1145     */
1146  }, {
1147    key: 'stuckAtPlaylistEnd_',
1148    value: function stuckAtPlaylistEnd_(playlist) {
1149      var seekable = this.seekable();
1150
1151      if (!seekable.length) {
1152        // playlist doesn't have enough information to determine whether we are stuck
1153        return false;
1154      }
1155
1156      var expired = this.syncController_.getExpiredTime(playlist, this.mediaSource.duration);
1157
1158      if (expired === null) {
1159        return false;
1160      }
1161
1162      // does not use the safe live end to calculate playlist end, since we
1163      // don't want to say we are stuck while there is still content
1164      var absolutePlaylistEnd = Hls.Playlist.playlistEnd(playlist, expired);
1165      var currentTime = this.tech_.currentTime();
1166      var buffered = this.tech_.buffered();
1167
1168      if (!buffered.length) {
1169        // return true if the playhead reached the absolute end of the playlist
1170        return absolutePlaylistEnd - currentTime <= _ranges2['default'].TIME_FUDGE_FACTOR;
1171      }
1172      var bufferedEnd = buffered.end(buffered.length - 1);
1173
1174      // return true if there is too little buffer left and
1175      // buffer has reached absolute end of playlist
1176      return bufferedEnd - currentTime <= _ranges2['default'].TIME_FUDGE_FACTOR && absolutePlaylistEnd - bufferedEnd <= _ranges2['default'].TIME_FUDGE_FACTOR;
1177    }
1178
1179    /**
1180     * Blacklists a playlist when an error occurs for a set amount of time
1181     * making it unavailable for selection by the rendition selection algorithm
1182     * and then forces a new playlist (rendition) selection.
1183     *
1184     * @param {Object=} error an optional error that may include the playlist
1185     * to blacklist
1186     * @param {Number=} blacklistDuration an optional number of seconds to blacklist the
1187     * playlist
1188     */
1189  }, {
1190    key: 'blacklistCurrentPlaylist',
1191    value: function blacklistCurrentPlaylist(error, blacklistDuration) {
1192      if (error === undefined) error = {};
1193
1194      var currentPlaylist = undefined;
1195      var nextPlaylist = undefined;
1196
1197      // If the `error` was generated by the playlist loader, it will contain
1198      // the playlist we were trying to load (but failed) and that should be
1199      // blacklisted instead of the currently selected playlist which is likely
1200      // out-of-date in this scenario
1201      currentPlaylist = error.playlist || this.masterPlaylistLoader_.media();
1202
1203      // If there is no current playlist, then an error occurred while we were
1204      // trying to load the master OR while we were disposing of the tech
1205      if (!currentPlaylist) {
1206        this.error = error;
1207
1208        try {
1209          return this.mediaSource.endOfStream('network');
1210        } catch (e) {
1211          return this.trigger('error');
1212        }
1213      }
1214
1215      var isFinalRendition = this.masterPlaylistLoader_.isFinalRendition_();
1216
1217      if (isFinalRendition) {

1218        // Never blacklisting this playlist because it's final rendition
1219        _videoJs2['default'].log.warn('Problem encountered with the current ' + 'HLS playlist. Trying again since it is the final playlist.');
1220
1221        this.tech_.trigger('retryplaylist');
1222        return this.masterPlaylistLoader_.load(isFinalRendition);
1223      }
1224      // Blacklist this playlist
1225      currentPlaylist.excludeUntil = Date.now() + (blacklistDuration ? blacklistDuration : this.blacklistDuration) * 1000;
1226      this.tech_.trigger('blacklistplaylist');
1227      this.tech_.trigger({ type: 'usage', name: 'hls-rendition-blacklisted' });
1228
1229      // Select a new playlist
1230      nextPlaylist = this.selectPlaylist();
1231      _videoJs2['default'].log.warn('Problem encountered with the current HLS playlist.' + (error.message ? ' ' + error.message : '') + ' Switching to another playlist.');
1232
1233      return this.masterPlaylistLoader_.media(nextPlaylist);
1234    }
1235
1236    /**
1237     * Pause all segment loaders
1238     */
1239  }, {
1240    key: 'pauseLoading',
1241    value: function pauseLoading() {
1242      this.mainSegmentLoader_.pause();
1243      if (this.mediaTypes_.AUDIO.activePlaylistLoader) {
1244        this.audioSegmentLoader_.pause();
1245      }
1246      if (this.mediaTypes_.SUBTITLES.activePlaylistLoader) {
1247        this.subtitleSegmentLoader_.pause();
1248      }
1249    }
1250
1251    /**
1252     * set the current time on all segment loaders
1253     *
1254     * @param {TimeRange} currentTime the current time to set
1255     * @return {TimeRange} the current time
1256     */
1257  }, {
1258    key: 'setCurrentTime',
1259    value: function setCurrentTime(currentTime) {
1260      var buffered = _ranges2['default'].findRange(this.tech_.buffered(), currentTime);
1261
1262      if (!(this.masterPlaylistLoader_ && this.masterPlaylistLoader_.media())) {
1263        // return immediately if the metadata is not ready yet
1264        return 0;
1265      }
1266
1267      // it's clearly an edge-case but don't thrown an error if asked to
1268      // seek within an empty playlist
1269      if (!this.masterPlaylistLoader_.media().segments) {
1270        return 0;
1271      }
1272
1273      // In flash playback, the segment loaders should be reset on every seek, even
1274      // in buffer seeks
1275      var isFlash = this.mode_ === 'flash' || this.mode_ === 'auto' && !_videoJs2['default'].MediaSource.supportsNativeMediaSources();
1276
1277      // if the seek location is already buffered, continue buffering as
1278      // usual
1279      if (buffered && buffered.length && !isFlash) {
1280        return currentTime;
1281      }
1282
1283      // cancel outstanding requests so we begin buffering at the new
1284      // location
1285      this.mainSegmentLoader_.resetEverything();
1286      this.mainSegmentLoader_.abort();
1287      if (this.mediaTypes_.AUDIO.activePlaylistLoader) {
1288        this.audioSegmentLoader_.resetEverything();
1289        this.audioSegmentLoader_.abort();
1290      }
1291      if (this.mediaTypes_.SUBTITLES.activePlaylistLoader) {
1292        this.subtitleSegmentLoader_.resetEverything();
1293        this.subtitleSegmentLoader_.abort();
1294      }
1295
1296      // start segment loader loading in case they are paused
1297      this.load();
1298    }
1299
1300    /**
1301     * get the current duration
1302     *
1303     * @return {TimeRange} the duration
1304     */
1305  }, {
1306    key: 'duration',
1307    value: function duration() {
1308      if (!this.masterPlaylistLoader_) {
1309        return 0;
1310      }
1311
1312      if (this.mediaSource) {
1313        return this.mediaSource.duration;
1314      }
1315
1316      return Hls.Playlist.duration(this.masterPlaylistLoader_.media());
1317    }
1318
1319    /**
1320     * check the seekable range
1321     *
1322     * @return {TimeRange} the seekable range
1323     */
1324  }, {
1325    key: 'seekable',
1326    value: function seekable() {
1327      return this.seekable_;
1328    }
1329  }, {
1330    key: 'onSyncInfoUpdate_',
1331    value: function onSyncInfoUpdate_() {
1332      var mainSeekable = undefined;
1333      var audioSeekable = undefined;
1334
1335      if (!this.masterPlaylistLoader_) {
1336        return;
1337      }
1338
1339      var media = this.masterPlaylistLoader_.media();
1340
1341      if (!media) {
1342        return;
1343      }
1344
1345      var expired = this.syncController_.getExpiredTime(media, this.mediaSource.duration);
1346
1347      if (expired === null) {
1348        // not enough information to update seekable
1349        return;
1350      }
1351
1352      mainSeekable = Hls.Playlist.seekable(media, expired);
1353
1354      if (mainSeekable.length === 0) {
1355        return;
1356      }
1357
1358      if (this.mediaTypes_.AUDIO.activePlaylistLoader) {
1359        media = this.mediaTypes_.AUDIO.activePlaylistLoader.media();
1360        expired = this.syncController_.getExpiredTime(media, this.mediaSource.duration);
1361
1362        if (expired === null) {
1363          return;
1364        }
1365
1366        audioSeekable = Hls.Playlist.seekable(media, expired);
1367
1368        if (audioSeekable.length === 0) {
1369          return;
1370        }
1371      }
1372
1373      if (!audioSeekable) {
1374        // seekable has been calculated based on buffering video data so it
1375        // can be returned directly
1376        this.seekable_ = mainSeekable;
1377      } else if (audioSeekable.start(0) > mainSeekable.end(0) || mainSeekable.start(0) > audioSeekable.end(0)) {
1378        // seekables are pretty far off, rely on main
1379        this.seekable_ = mainSeekable;
1380      } else {
1381        this.seekable_ = _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)]]);
1382      }
1383
1384      this.tech_.trigger('seekablechanged');
1385    }
1386
1387    /**
1388     * Update the player duration
1389     */
1390  }, {
1391    key: 'updateDuration',
1392    value: function updateDuration() {
1393      var _this4 = this;
1394
1395      var oldDuration = this.mediaSource.duration;
1396      var newDuration = Hls.Playlist.duration(this.masterPlaylistLoader_.media());
1397      var buffered = this.tech_.buffered();
1398      var setDuration = function setDuration() {
1399        _this4.mediaSource.duration = newDuration;
1400        _this4.tech_.trigger('durationchange');
1401
1402        _this4.mediaSource.removeEventListener('sourceopen', setDuration);
1403      };
1404
1405      if (buffered.length > 0) {
1406        newDuration = Math.max(newDuration, buffered.end(buffered.length - 1));
1407      }
1408
1409      // if the duration has changed, invalidate the cached value
1410      if (oldDuration !== newDuration) {
1411        // update the duration
1412        if (this.mediaSource.readyState !== 'open') {
1413          this.mediaSource.addEventListener('sourceopen', setDuration);
1414        } else {
1415          setDuration();
1416        }
1417      }
1418    }
1419
1420    /**
1421     * dispose of the MasterPlaylistController and everything
1422     * that it controls
1423     */
1424  }, {
1425    key: 'dispose',
1426    value: function dispose() {
1427      var _this5 = this;
1428
1429      this.decrypter_.terminate();
1430      this.masterPlaylistLoader_.dispose();
1431      this.mainSegmentLoader_.dispose();
1432
1433      ['AUDIO', 'SUBTITLES'].forEach(function (type) {
1434        var groups = _this5.mediaTypes_[type].groups;
1435
1436        for (var id in groups) {

1437          groups[id].forEach(function (group) {
1438            if (group.playlistLoader) {
1439              group.playlistLoader.dispose();
1440            }
1441          });
1442        }
1443      });
1444
1445      this.audioSegmentLoader_.dispose();
1446      this.subtitleSegmentLoader_.dispose();
1447    }
1448
1449    /**
1450     * return the master playlist object if we have one
1451     *
1452     * @return {Object} the master playlist object that we parsed
1453     */
1454  }, {
1455    key: 'master',
1456    value: function master() {
1457      return this.masterPlaylistLoader_.master;
1458    }
1459
1460    /**
1461     * return the currently selected playlist
1462     *
1463     * @return {Object} the currently selected playlist object that we parsed
1464     */
1465  }, {
1466    key: 'media',
1467    value: function media() {
1468      // playlist loader will not return media if it has not been fully loaded
1469      return this.masterPlaylistLoader_.media() || this.initialMedia_;
1470    }
1471
1472    /**
1473     * setup our internal source buffers on our segment Loaders
1474     *
1475     * @private
1476     */
1477  }, {
1478    key: 'setupSourceBuffers_',
1479    value: function setupSourceBuffers_() {
1480      var media = this.masterPlaylistLoader_.media();
1481      var mimeTypes = undefined;
1482
1483      // wait until a media playlist is available and the Media Source is
1484      // attached
1485      if (!media || this.mediaSource.readyState !== 'open') {
1486        return;
1487      }
1488
1489      mimeTypes = mimeTypesForPlaylist_(this.masterPlaylistLoader_.master, media);
1490      if (mimeTypes.length < 1) {
1491        this.error = 'No compatible SourceBuffer configuration for the variant stream:' + media.resolvedUri;
1492        return this.mediaSource.endOfStream('decode');
1493      }
1494      this.mainSegmentLoader_.mimeType(mimeTypes[0]);
1495      if (mimeTypes[1]) {
1496        this.audioSegmentLoader_.mimeType(mimeTypes[1]);
1497      }
1498
1499      // exclude any incompatible variant streams from future playlist
1500      // selection
1501      this.excludeIncompatibleVariants_(media);
1502    }
1503
1504    /**
1505     * Blacklist playlists that are known to be codec or
1506     * stream-incompatible with the SourceBuffer configuration. For
1507     * instance, Media Source Extensions would cause the video element to
1508     * stall waiting for video data if you switched from a variant with
1509     * video and audio to an audio-only one.
1510     *
1511     * @param {Object} media a media playlist compatible with the current
1512     * set of SourceBuffers. Variants in the current master playlist that
1513     * do not appear to have compatible codec or stream configurations
1514     * will be excluded from the default playlist selection algorithm
1515     * indefinitely.
1516     * @private
1517     */
1518  }, {
1519    key: 'excludeIncompatibleVariants_',
1520    value: function excludeIncompatibleVariants_(media) {
1521      var master = this.masterPlaylistLoader_.master;
1522      var codecCount = 2;
1523      var videoCodec = null;
1524      var codecs = undefined;
1525
1526      if (media.attributes.CODECS) {
1527        codecs = (0, _utilCodecsJs.parseCodecs)(media.attributes.CODECS);
1528        videoCodec = codecs.videoCodec;
1529        codecCount = codecs.codecCount;
1530      }

1531      master.playlists.forEach(function (variant) {
1532        var variantCodecs = {
1533          codecCount: 2,
1534          videoCodec: null
1535        };
1536
1537        if (variant.attributes.CODECS) {
1538          var codecString = variant.attributes.CODECS;
1539
1540          variantCodecs = (0, _utilCodecsJs.parseCodecs)(codecString);
1541
1542          if (window.MediaSource && window.MediaSource.isTypeSupported && !window.MediaSource.isTypeSupported('video/mp4; codecs="' + mapLegacyAvcCodecs_(codecString) + '"')) {
1543            variant.excludeUntil = Infinity;
1544          }
1545        }
1546
1547        // if the streams differ in the presence or absence of audio or
1548        // video, they are incompatible
1549        if (variantCodecs.codecCount !== codecCount) {
1550          variant.excludeUntil = Infinity;
1551        }
1552
1553        // if h.264 is specified on the current playlist, some flavor of
1554        // it must be specified on all compatible variants
1555        if (variantCodecs.videoCodec !== videoCodec) {
1556          variant.excludeUntil = Infinity;
1557        }
1558      });
1559    }
1560  }, {
1561    key: 'updateAdCues_',
1562    value: function updateAdCues_(media) {
1563      var offset = 0;
1564      var seekable = this.seekable();
1565
1566      if (seekable.length) {
1567        offset = seekable.start(0);
1568      }
1569
1570      _adCueTags2['default'].updateAdCues(media, this.cueTagsTrack_, offset);
1571    }
1572
1573    /**
1574     * Calculates the desired forward buffer length based on current time
1575     *
1576     * @return {Number} Desired forward buffer length in seconds
1577     */
1578  }, {
1579    key: 'goalBufferLength',
1580    value: function goalBufferLength() {
1581      var currentTime = this.tech_.currentTime();
1582      var initial = _config2['default'].GOAL_BUFFER_LENGTH;
1583      var rate = _config2['default'].GOAL_BUFFER_LENGTH_RATE;
1584      var max = Math.max(initial, _config2['default'].MAX_GOAL_BUFFER_LENGTH);
1585
1586      return Math.min(initial + currentTime * rate, max);
1587    }
1588
1589    /**
1590     * Calculates the desired buffer low water line based on current time
1591     *
1592     * @return {Number} Desired buffer low water line in seconds
1593     */
1594  }, {
1595    key: 'bufferLowWaterLine',
1596    value: function bufferLowWaterLine() {
1597      var currentTime = this.tech_.currentTime();
1598      var initial = _config2['default'].BUFFER_LOW_WATER_LINE;
1599      var rate = _config2['default'].BUFFER_LOW_WATER_LINE_RATE;
1600      var max = Math.max(initial, _config2['default'].MAX_BUFFER_LOW_WATER_LINE);
1601
1602      return Math.min(initial + currentTime * rate, max);
1603    }
1604  }]);
1605
1606  return MasterPlaylistController;
1607})(_videoJs2['default'].EventTarget);
1608
1609exports.MasterPlaylistController = MasterPlaylistController;
1610}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
1611},{"./ad-cue-tags":1,"./config":3,"./decrypter-worker":4,"./media-groups":6,"./playlist-loader":9,"./ranges":12,"./segment-loader":16,"./sync-controller":18,"./util/codecs.js":19,"./vtt-segment-loader":20,"videojs-contrib-media-sources/es5/codec-utils":65,"webworkify":76}],6:[function(require,module,exports){
1612(function (global){
1613'use strict';
1614
1615Object.defineProperty(exports, '__esModule', {
1616  value: true
1617});
1618
1619function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
1620
1621var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
1622
1623var _videoJs2 = _interopRequireDefault(_videoJs);
1624
1625var _playlistLoader = require('./playlist-loader');
1626
1627var _playlistLoader2 = _interopRequireDefault(_playlistLoader);
1628
1629var noop = function noop() {};
1630
1631/**
1632 * Convert the properties of an HLS track into an audioTrackKind.
1633 *
1634 * @private
1635 */
1636var audioTrackKind_ = function audioTrackKind_(properties) {
1637  var kind = properties['default'] ? 'main' : 'alternative';
1638
1639  if (properties.characteristics && properties.characteristics.indexOf('public.accessibility.describes-video') >= 0) {
1640    kind = 'main-desc';
1641  }
1642
1643  return kind;
1644};
1645
1646/**
1647 * Pause provided segment loader and playlist loader if active
1648 *
1649 * @param {SegmentLoader} segmentLoader
1650 *        SegmentLoader to pause
1651 * @param {Object} mediaType
1652 *        Active media type
1653 * @function stopLoaders
1654 */
1655var stopLoaders = function stopLoaders(segmentLoader, mediaType) {
1656  segmentLoader.abort();
1657  segmentLoader.pause();
1658
1659  if (mediaType && mediaType.activePlaylistLoader) {
1660    mediaType.activePlaylistLoader.pause();
1661    mediaType.activePlaylistLoader = null;
1662  }
1663};
1664
1665exports.stopLoaders = stopLoaders;
1666/**
1667 * Start loading provided segment loader and playlist loader
1668 *
1669 * @param {PlaylistLoader} playlistLoader
1670 *        PlaylistLoader to start loading
1671 * @param {Object} mediaType
1672 *        Active media type
1673 * @function startLoaders
1674 */
1675var startLoaders = function startLoaders(playlistLoader, mediaType) {
1676  // Segment loader will be started after `loadedmetadata` or `loadedplaylist` from the
1677  // playlist loader
1678  mediaType.activePlaylistLoader = playlistLoader;
1679  playlistLoader.load();
1680};
1681
1682exports.startLoaders = startLoaders;
1683/**
1684 * Returns a function to be called when the media group changes. It performs a
1685 * non-destructive (preserve the buffer) resync of the SegmentLoader. This is because a
1686 * change of group is merely a rendition switch of the same content at another encoding,
1687 * rather than a change of content, such as switching audio from English to Spanish.
1688 *
1689 * @param {String} type
1690 *        MediaGroup type
1691 * @param {Object} settings
1692 *        Object containing required information for media groups
1693 * @return {Function}
1694 *         Handler for a non-destructive resync of SegmentLoader when the active media
1695 *         group changes.
1696 * @function onGroupChanged
1697 */
1698var onGroupChanged = function onGroupChanged(type, settings) {
1699  return function () {
1700    var _settings$segmentLoaders = settings.segmentLoaders;
1701    var segmentLoader = _settings$segmentLoaders[type];
1702    var mainSegmentLoader = _settings$segmentLoaders.main;
1703    var mediaType = settings.mediaTypes[type];
1704
1705    var activeTrack = mediaType.activeTrack();
1706    var activeGroup = mediaType.activeGroup(activeTrack);
1707    var previousActiveLoader = mediaType.activePlaylistLoader;
1708
1709    stopLoaders(segmentLoader, mediaType);
1710
1711    if (!activeGroup) {
1712      // there is no group active
1713      return;
1714    }
1715
1716    if (!activeGroup.playlistLoader) {
1717      if (previousActiveLoader) {
1718        // The previous group had a playlist loader but the new active group does not
1719        // this means we are switching from demuxed to muxed audio. In this case we want to
1720        // do a destructive reset of the main segment loader and n

1720ot restart the audio
1721        // loaders.
1722        mainSegmentLoader.resetEverything();
1723      }
1724      return;
1725    }
1726
1727    // Non-destructive resync
1728    segmentLoader.resyncLoader();
1729
1730    startLoaders(activeGroup.playlistLoader, mediaType);
1731  };
1732};
1733
1734exports.onGroupChanged = onGroupChanged;
1735/**
1736 * Returns a function to be called when the media track changes. It performs a
1737 * destructive reset of the SegmentLoader to ensure we start loading as close to
1738 * currentTime as possible.
1739 *
1740 * @param {String} type
1741 *        MediaGroup type
1742 * @param {Object} settings
1743 *        Object containing required information for media groups
1744 * @return {Function}
1745 *         Handler for a destructive reset of SegmentLoader when the active media
1746 *         track changes.
1747 * @function onTrackChanged
1748 */
1749var onTrackChanged = function onTrackChanged(type, settings) {
1750  return function () {
1751    var _settings$segmentLoaders2 = settings.segmentLoaders;
1752    var segmentLoader = _settings$segmentLoaders2[type];
1753    var mainSegmentLoader = _settings$segmentLoaders2.main;
1754    var mediaType = settings.mediaTypes[type];
1755
1756    var activeTrack = mediaType.activeTrack();
1757    var activeGroup = mediaType.activeGroup(activeTrack);
1758    var previousActiveLoader = mediaType.activePlaylistLoader;
1759
1760    stopLoaders(segmentLoader, mediaType);
1761
1762    if (!activeGroup) {
1763      // there is no group active so we do not want to restart loaders
1764      return;
1765    }
1766
1767    if (!activeGroup.playlistLoader) {
1768      // when switching from demuxed audio/video to muxed audio/video (noted by no playlist
1769      // loader for the audio group), we want to do a destructive reset of the main segment
1770      // loader and not restart the audio loaders
1771      mainSegmentLoader.resetEverything();
1772      return;
1773    }
1774
1775    if (previousActiveLoader === activeGroup.playlistLoader) {
1776      // Nothing has actually changed. This can happen because track change events can fire
1777      // multiple times for a "single" change. One for enabling the new active track, and
1778      // one for disabling the track that was active
1779      startLoaders(activeGroup.playlistLoader, mediaType);
1780      return;
1781    }
1782
1783    if (segmentLoader.track) {
1784      // For WebVTT, set the new text track in the segmentloader
1785      segmentLoader.track(activeTrack);
1786    }
1787
1788    // destructive reset
1789    segmentLoader.resetEverything();
1790
1791    startLoaders(activeGroup.playlistLoader, mediaType);
1792  };
1793};
1794
1795exports.onTrackChanged = onTrackChanged;
1796var onError = {
1797  /**
1798   * Returns a function to be called when a SegmentLoader or PlaylistLoader encounters
1799   * an error.
1800   *
1801   * @param {String} type
1802   *        MediaGroup type
1803   * @param {Object} settings
1804   *        Object containing required information for media groups
1805   * @return {Function}
1806   *         Error handler. Logs warning (or error if the playlist is blacklisted) to
1807   *         console and switches back to default audio track.
1808   * @function onError.AUDIO
1809   */
1810  AUDIO: function AUDIO(type, settings) {
1811    return function () {
1812      var segmentLoader = settings.segmentLoaders[type];
1813      var mediaType = settings.mediaTypes[type];
1814      var blacklistCurrentPlaylist = settings.blacklistCurrentPlaylist;
1815
1816      stopLoaders(segmentLoader, mediaType);
1817
1818      // switch back to default audio track
1819      var activeTrack = mediaType.activeTrack();
1820      var activeGroup = mediaType.activeGroup();
1821      var id = (activeGroup.filter(function (group) {
1822        return group['default'];
1823      })[0] || activeGroup[0]).id;
1824      var defaultTrack = mediaType.tracks[id];
1825
1826      if (activeTrack === defaultTrack) {
1827        // Default track encountered an error. All we can do now is blacklist the current
1828        // rendition and hope another will switch audio groups
1829        blacklistCurrentPlaylist({
1830          message: 'Problem encountered loading the default audio track.'
1831        });
1832        return;
1833      }
1834
1835      _videoJs2['default'].log.warn('Problem encountered loading the alternate audio track.' + 'Switching back to default.');
1836
1837      for (var trackId in mediaType.tracks) {
1838        mediaType.tracks[trackId].enabled = mediaType.tracks[trackId] === defaultTrack;
1839      }
1840
1841      mediaType.onTrackChanged();
1842    };
1843  },
1844  /**
1845   * Returns a function to be called when a SegmentLoader or PlaylistLoader encounters
1846   * an error.
1847   *
1848   * @param {String} type
1849   *        MediaGroup type
1850   * @param {Object} settings
1851   *        Object containing required information for media groups
1852   * @return {Function}
1853   *         Error handler. Logs warning to console and disables the active subtitle track
1854   * @function onError.SUBTITLES
1855   */
1856  SUBTITLES: function SUBTITLES(type, settings) {
1857    return function () {
1858      var segmentLoader = settings.segmentLoaders[type];
1859      var mediaType = settings.mediaTypes[type];
1860
1861      _videoJs2['default'].log.warn('Problem encountered loading the subtitle track.' + 'Disabling subtitle track.');
1862
1863      stopLoaders(segmentLoader, mediaType);
1864
1865      var track = mediaType.activeTrack();
1866
1867      if (track) {
1868        track.mode = 'disabled';
1869      }
1870
1871      mediaType.onTrackChanged();
1872    };
1873  }
1874};
1875
1876exports.onError = onError;
1877var setupListeners = {
1878  /**
1879   * Setup event listeners for audio playlist loader
1880   *
1881   * @param {String} type
1882   *        MediaGroup type
1883   * @param {PlaylistLoader|null} playlistLoader
1884   *        PlaylistLoader to register listeners on
1885   * @param {Object} settings
1886   *        Object containing required information for media groups
1887   * @function setupListeners.AUDIO
1888   */
1889  AUDIO: function AUDIO(type, playlistLoader, settings) {
1890    if (!playlistLoader) {
1891      // no playlist loader means audio will be muxed with the video
1892      return;
1893    }
1894
1895    var tech = settings.tech;
1896    var requestOptions = settings.requestOptions;
1897    var segmentLoader = settings.segmentLoaders[type];
1898
1899    playlistLoader.on('loadedmetadata', function () {
1900      var media = playlistLoader.media();
1901
1902      segmentLoader.playlist(media, requestOptions);
1903
1904      // if the video is already playing, or if this isn't a live video and preload
1905      // permits, start downloading segments
1906      if (!tech.paused() || media.endList && tech.preload() !== 'none') {
1907        segmentLoader.load();
1908      }
1909    });
1910
1911    playlistLoader.on('loadedplaylist', function () {
1912      segmentLoader.playlist(playlistLoader.media(), requestOptions);
1913
1914      // If the player isn't paused, ensure that the segment loader is running
1915      if (!tech.paused()) {
1916        segmentLoader.load();
1917      }
1918    });
1919
1920    playlistLoader.on('error', onError[type](type, settings));
1921  },
1922  /**
1923   * Setup event listeners for subtitle playlist loader
1924   *
1925   * @param {String} type
1926   *        MediaGroup type
1927   * @param {PlaylistLoader|null} playlistLoader
1928   *        PlaylistLoader to register listeners on
1929   * @param {Object} settings
1930   *        Object containing required information for media groups
1931   * @function setupListeners.SUBTITLES
1932   */
1933  SUBTITLES: function SUBTITLES(type, playlistLoader, settings) {
1934    var tech = settings.tech;
1935    var requestOptions = settings.requestOptions;
1936    var segmentLoader = settings.segmentLoaders[type];
1937    var mediaType = settings.mediaTypes[type];
1938
1939    playlistLoader.on('loadedmetadata', function () {
1940      var media = playlistLoader.media();
1941
1942      segmentLoader.playlist(media, requestOptions);
1943      segmentLoader.track(mediaType.activeTrack());
1944
1945      // if the video is already playing, or if this isn't a live video and preload
1946      // permits, start downloading segments
1947      if (!tech.paused() || media.endList && tech.preload() !== 'none') {
1948        segmentLoader.load();
1949      }
1950    });
1951
1952    playlistLoader.on('loadedplaylist', function () {
1953      segmentLoader.playlist(playlistLoader.media(), requestOptions);
1954
1955      // If the player isn't paused, ensure that the segment loader is running
1956      if (!tech.paused()) {
1957        segmentLoader.load();
1958      }
1959    });
1960
1961    playlistLoader.on('error', onError[type](type, settings));
1962  }
1963};
1964
1965exports.setupListeners = setupListeners;
1966var initialize = {
1967  /**
1968   * Setup PlaylistLoaders and AudioTracks for the audio groups
1969   *
1970   * @param {String} type
1971   *        MediaGroup type
1972   * @param {Object} settings
1973   *        Object containing required information for media groups
1974   * @function initialize.AUDIO
1975   */
1976  'AUDIO': function AUDIO(type, settings) {
1977    var mode = settings.mode;
1978    var hls = settings.hls;
1979    var segmentLoader = settings.segmentLoaders[type];
1980    var withCredentials = settings.requestOptions.withCredentials;
1981    var mediaGroups = settings.master.mediaGroups;
1982    var _settings$mediaTypes$type = settings.mediaTypes[type];
1983    var groups = _settings$mediaTypes$type.groups;
1984    var tracks = _settings$mediaTypes$type.tracks;
1985
1986    // force a default if we have none or we are not

1987    // in html5 mode (the only mode to support more than one
1988    // audio track)
1989    if (!mediaGroups[type] || Object.keys(mediaGroups[type]).length === 0 || mode !== 'html5') {
1990      mediaGroups[type] = { main: { 'default': { 'default': true } } };
1991    }
1992
1993    for (var groupId in mediaGroups[type]) {
1994      if (!groups[groupId]) {
1995        groups[groupId] = [];
1996      }
1997
1998      for (var variantLabel in mediaGroups[type][groupId]) {
1999        var properties = mediaGroups[type][groupId][variantLabel];
2000        var playlistLoader = undefined;
2001
2002        if (properties.resolvedUri) {
2003          playlistLoader = new _playlistLoader2['default'](properties.resolvedUri, hls, withCredentials);
2004        } else {
2005          // no resolvedUri means the audio is muxed with the video when using this
2006          // audio track
2007          playlistLoader = null;
2008        }
2009
2010        properties = _videoJs2['default'].mergeOptions({ id: variantLabel, playlistLoader: playlistLoader }, properties);
2011
2012        setupListeners[type](type, properties.playlistLoader, settings);
2013
2014        groups[groupId].push(properties);
2015
2016        if (typeof tracks[variantLabel] === 'undefined') {
2017          var track = new _videoJs2['default'].AudioTrack({
2018            id: variantLabel,
2019            kind: audioTrackKind_(properties),
2020            enabled: false,
2021            language: properties.language,
2022            'default': properties['default'],
2023            label: variantLabel
2024          });
2025
2026          tracks[variantLabel] = track;
2027        }
2028      }
2029    }
2030
2031    // setup single error event handler for the segment loader
2032    segmentLoader.on('error', onError[type](type, settings));
2033  },
2034  /**
2035   * Setup PlaylistLoaders and TextTracks for the subtitle groups
2036   *
2037   * @param {String} type
2038   *        MediaGroup type
2039   * @param {Object} settings
2040   *        Object containing required information for media groups
2041   * @function initialize.SUBTITLES
2042   */
2043  'SUBTITLES': function SUBTITLES(type, settings) {
2044    var tech = settings.tech;
2045    var hls = settings.hls;
2046    var segmentLoader = settings.segmentLoaders[type];
2047    var withCredentials = settings.requestOptions.withCredentials;
2048    var mediaGroups = settings.master.mediaGroups;
2049    var _settings$mediaTypes$type2 = settings.mediaTypes[type];
2050    var groups = _settings$mediaTypes$type2.groups;
2051    var tracks = _settings$mediaTypes$type2.tracks;
2052
2053    for (var groupId in mediaGroups[type]) {
2054      if (!groups[groupId]) {
2055        groups[groupId] = [];
2056      }
2057
2058      for (var variantLabel in mediaGroups[type][groupId]) {
2059        if (mediaGroups[type][groupId][variantLabel].forced) {
2060          // Subtitle playlists with the forced attribute are not selectable in Safari.
2061          // According to Apple's HLS Authoring Specification:
2062          //   If content has forced subtitles and regular subtitles in a given language,
2063          //   the regular subtitles track in that language MUST contain both the forced
2064          //   subtitles and the regular subtitles for that language.
2065          // Because of this requirement and that Safari does not add forced subtitles,
2066          // forced subtitles are skipped here to maintain consistent experience across
2067          // all platforms
2068          continue;
2069        }
2070
2071        var properties = mediaGroups[type][groupId][variantLabel];
2072
2073        properties = _videoJs2['default'].mergeOptions({
2074          id: variantLabel,
2075          playlistLoader: new _playlistLoader2['default'](properties.resolvedUri, hls, withCredentials)
2076        }, properties);
2077
2078        setupListeners[type](type, properties.playlistLoader, settings);
2079
2080        groups[groupId].push(properties);
2081
2082        if (typeof tracks[variantLabel] === 'undefined') {
2083          var track = tech.addRemoteTextTrack({
2084            id: variantLabel,
2085            kind: 'subtitles',
2086            enabled: false,
2087            language: properties.language,
2088            label: variantLabel
2089          }, false).track;
2090
2091          tracks[variantLabel] = track;
2092        }
2093      }
2094    }
2095
2096    // setup single error event handler for the segment loader
2097    segmentLoader.on('error', onError[type](type, settings));
2098  },
2099  /**
2100   * Setup TextTracks for the closed-caption groups
2101   *
2102   * @param {String} type
2103   *        MediaGroup type
2104   * @param {Object} settings
2105   *        Object containing required information for media groups
2106   * @function initialize['CLOSED-CAPTIONS']
2107   */
2108  'CLOSED-CAPTIONS': function CLOSEDCAPTIONS(type, settings) {
2109    var tech = settings.tech;
2110    var mediaGroups = settings.master.mediaGroups;
2111    var _settings$mediaTypes$type3 = settings.mediaTypes[type];
2112    var groups = _settings$mediaTypes$type3.groups;
2113    var tracks = _settings$mediaTypes$type3.tracks;
2114
2115    for (var groupId in mediaGroups[type]) {
2116      if (!groups[groupId]) {
2117        groups[groupId] = [];
2118      }
2119
2120      for (var variantLabel in mediaGroups[type][groupId]) {
2121        var properties = mediaGroups[type][groupId][variantLabel];
2122
2123        // We only support CEA608 captions for now, so ignore anything that
2124        // doesn't use a CCx INSTREAM-ID
2125        if (!properties.instreamId.match(/CC\d/)) {
2126          continue;
2127        }
2128
2129        // No PlaylistLoader is required for Closed-Captions because the captions are
2130        // embedded within the video stream
2131        groups[groupId].push(_videoJs2['default'].mergeOptions({ id: variantLabel }, properties));
2132
2133        if (typeof tracks[variantLabel] === 'undefined') {
2134          var track = tech.addRemoteTextTrack({
2135            id: properties.instreamId,
2136            kind: 'captions',
2137            enabled: false,
2138            language: properties.language,
2139            label: variantLabel
2140          }, false).track;
2141
2142          tracks[variantLabel] = track;
2143        }
2144      }
2145    }
2146  }
2147};
2148
2149exports.initialize = initialize;
2150/**
2151 * Returns a function used to get the active group of the provided type
2152 *
2153 * @param {String} type
2154 *        MediaGroup type
2155 * @param {Object} settings
2156 *        Object containing required information for media groups
2157 * @return {Function}
2158 *         Function that returns the active media group for the provided type. Takes an
2159 *         optional parameter {TextTrack} track. If no track is provided, a list of all
2160 *         variants in the group, otherwise the variant corresponding to the provided
2161 *         track is returned.
2162 * @function activeGroup
2163 */
2164var activeGroup = function activeGroup(type, settings) {
2165  return function (track) {
2166    var masterPlaylistLoader = settings.masterPlaylistLoader;
2167    var groups = settings.mediaTypes[type].groups;
2168
2169    var media = masterPlaylistLoader.media();
2170
2171    if (!media) {
2172      return null;
2173    }
2174
2175    var variants = null;
2176
2177    if (media.attributes[type]) {
2178      variants = groups[media.attributes[type]];
2179    }
2180
2181    variants = variants || groups.main;
2182
2183    if (typeof track === 'undefined') {
2184      return variants;
2185    }
2186
2187    if (track === null) {
2188      // An active track was specified so a corresponding group is expected. track === null
2189      // means no track is currently active so there is no corresponding group
2190      return null;
2191    }
2192
2193    return variants.filter(function (props) {
2194      return props.id === track.id;
2195    })[0] || null;
2196  };
2197};
2198
2199exports.activeGroup = activeGroup;
2200var activeTrack = {
2201  /**
2202   * Returns a function used to get the active track of type provided
2203   *
2204   * @param {String} type
2205   *        MediaGroup type
2206   * @param {Object} settings
2207   *        Object containing required information for media groups
2208   * @return {Function}
2209   *         Function that returns the active media track for the provided type. Returns
2210   *         null if no track is active
2211   * @function activeTrack.AUDIO
2212   */
2213  AUDIO: function AUDIO(type, settings) {
2214    return function () {
2215      var tracks = settings.mediaTypes[type].tracks;
2216
2217      for (var id in tracks) {
2218        if (tracks[id].enabled) {
2219          return tracks[id];
2220        }
2221      }
2222
2223      return null;
2224    };
2225  },
2226  /**
2227   * Returns a function used to get the active track of type provided
2228   *
2229   * @param {String} type
2230   *        MediaGroup type
2231   * @param {Object} settings
2232   *        Object containing required information for media groups
2233   * @return {Function}
2234   *         Function that returns the active media track for the provided type. Returns
2235   *         null if no track is active
2236   * @function activeTrack.SUBTITLES
2237   */
2238  SUBTITLES: function SUBTITLES(type, settings) {
2239    return function () {
2240      var tracks = settings.mediaTypes[type].tracks;
2241
2242      for (var id in tracks) {
2243        if (tracks[id].mode === 'showing') {
2244          return tracks[id];
2245        }
2246      }
2247
2248      return null;
2249    };
2250  }
2251};
2252
2253exports.activeTrack = activeTrack;
2254/**
2255 * Setup PlaylistLoaders and Tracks for media groups (Audio, Subtitles,
2256 * Closed-Captions) specified in the master manifest.
2257 *
2258 * @param {Object} settings
2259 *        Object containing required information for setting up the media groups
2260 * @param {SegmentLoader} settings.segmentLoaders.AUDIO
2261 *        Audio segment loader
2262 * @param {SegmentLoader} settings.segmentLoaders.SUBTITLES
2263 *        Subtitle segment loader
2264 * @param {SegmentLoader} settings.segmentLoaders.main
2265 *        Main segment loader
2266 * @param {Tech} settings.tech
2267 *        The tech of the player
2268 * @param {Object} settings.requestOptions
2269 *        XHR request options used by the segment loaders
2270 * @param {PlaylistLoader} settings.masterPlaylistLoader
2271 *        PlaylistLoader for the master source
2272 * @param {String} mode
2273 *        Mode of the hls source handler. Can be 'auto', 'html5', or 'flash'
2274 * @param {HlsHandler} settings.hls
2275 *        HLS SourceHandler
2276 * @param {Object} settings.master
2277 *        The parsed master manifest
2278 * @param {Object} settings.mediaTypes
2279 *        Object to store the loaders, tracks, and utility methods for each media type
2280 * @param {Function} settings.blacklistCurrentPlaylist
2281 *        Blacklists the current rendition and forces a rendition switch.
2282 * @function setupMediaGroups
2283 */
2284var setupMediaGroups = function setupMediaGroups(settings) {
2285  ['AUDIO', 'SUBTITLES', 'CLOSED-CAPTIONS'].forEach(function (type) {
2286    initialize[type](type, settings);
2287  });
2288
2289  var mediaTypes = settings.mediaTypes;
2290  var masterPlaylistLoader = settings.masterPlaylistLoader;
2291  var tech = settings.tech;
2292  var hls = settings.hls;
2293
2294  // setup active group and track getters and change event handlers
2295  ['AUDIO', 'SUBTITLES'].forEach(function (type) {
2296    mediaTypes[type].activeGroup = activeGroup(type, settings);
2297    mediaTypes[type].activeTrack = activeTrack[type](type, settings);
2298    mediaTypes[type].onGroupChanged = onGroupChanged(type, settings);
2299    mediaTypes[type].onTrackChanged = onTrackChanged(type, settings);
2300  });
2301
2302  // DO NOT enable the default subtitle or caption track.
2303  // DO enable the default audio track
2304  var audioGroup = mediaTypes.AUDIO.activeGroup();
2305  var groupId = (audioGroup.filter(function (group) {
2306    return group['default'];
2307  })[0] || audioGroup[0]).id;
2308
2309  mediaTypes.AUDIO.tracks[groupId].enabled = true;
2310  mediaTypes.AUDIO.onTrackChanged();
2311
2312  masterPlaylistLoader.on('mediachange', function () {
2313    ['AUDIO', 'SUBTITLES'].forEach(function (type) {
2314      return mediaTypes[type].onGroupChanged();
2315    });
2316  });
2317
2318  // custom audio track change event handler for usage event
2319  var onAudioTrackChanged = function onAudioTrackChanged() {
2320    mediaTypes.AUDIO.onTrackChanged();
2321    tech.trigger({ type: 'usage', name: 'hls-audio-change' });
2322  };
2323
2324  tech.audioTracks().addEventListener('change', onAudioTrackChanged);
2325  tech.remoteTextTracks().addEventListener('change', mediaTypes.SUBTITLES.onTrackChanged);
2326
2327  hls.on('dispose', function () {
2328    tech.audioTracks().removeEventListener('change', onAudioTrackChanged);
2329    tech.remoteTextTracks().removeEventListener('change', mediaTypes.SUBTITLES.onTrackChanged);
2330  });
2331
2332  // clear existing audio tracks and add the ones we just created
2333  tech.clearTracks('audio');
2334
2335  for (var id in mediaTypes.AUDIO.tracks) {
2336    tech.audioTracks().addTrack(mediaTypes.AUDIO.tracks[id]);
2337  }
2338};
2339
2340exports.setupMediaGroups = setupMediaGroups;
2341/**
2342 * Creates skeleton object used to store the loaders, tracks, and utility methods for each
2343 * media type
2344 *
2345 * @return {Object}
2346 *         Object to store the loaders, tracks, and utility methods for each media type
2347 * @function createMediaTypes
2348 */
2349var createMediaTypes = function createMediaTypes() {
2350  var mediaTypes = {};
2351
2352  ['AUDIO', 'SUBTITLES', 'CLOSED-CAPTIONS'].forEach(function (type) {
2353    mediaTypes[type] = {
2354      groups: {},
2355      tracks: {},
2356      activePlaylistLoader: null,
2357      activeGroup: noop,
2358      activeTrack: noop,
2359      onGroupChanged: noop,
2360      onTrackChanged: noop
2361    };
2362  });
2363
2364  return mediaTypes;
2365};
2366exports.createMediaTypes = createMediaTypes;
2367}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
2368},{"./playlist-loader":9}],7:[function(require,module,exports){
2369(function (global){
2370'use strict';
2371
2372Object.defineProperty(exports, '__esModule', {
2373  value: true
2374});
2375
2376function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
2377
2378var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof global !== "undefined" ? global['videojs'] : null);
2379
2380var _videoJs2 = _interopRequireDefault(_videoJs);
2381
2382var _binUtils = require('./bin-utils');
2383
2384var REQUEST_ERRORS = {
2385  FAILURE: 2,
2386  TIMEOUT: -101,
2387  ABORTED: -102
2388};
2389
2390exports.REQUEST_ERRORS = REQUEST_ERRORS;
2391/**
2392 * Turns segment byterange into a string suitable for use in
2393 * HTTP Range requests
2394 *
2395 * @param {Object} byterange - an object with two values defining the start and end
2396 *                             of a byte-range
2397 */
2398var byterangeStr = function byterangeStr(byterange) {
2399  var byterangeStart = undefined;
2400  var byterangeEnd = undefined;
2401
2402  // `byterangeEnd` is one less than `offset + length` because the HTTP range
2403  // header uses inclusive ranges
2404  byterangeEnd = byterange.offset + byterange.length - 1;
2405  byterangeStart = byterange.offset;
2406  return 'bytes=' + byterangeStart + '-' + byterangeEnd;
2407};
2408
2409/**
2410 * Defines headers for use in the xhr request for a particular segment.
2411 *
2412 * @param {Object} segment - a simplified copy of the segmentInfo object
2413 *                           from SegmentLoader
2414 */
2415var segmentXhrHeaders = function segmentXhrHeaders(segment) {
2416  var headers = {};
2417
2418  if (segment.byterange) {
2419    headers.Range = byterangeStr(segment.byterange);
2420  }
2421  return headers;
2422};
2423
2424/**
2425 * Abort all requests
2426 *
2427 * @param {Object} activeXhrs - an object that tracks all XHR requests
2428 */
2429var abortAll = function abortAll(activeXhrs) {

2430  activeXhrs.forEach(function (xhr) {
2431    xhr.abort();
2432  });
2433};
2434
2435/**
2436 * Gather important bandwidth stats once a request has completed
2437 *
2438 * @param {Object} request - the XHR request from which to gather stats
2439 */
2440var getRequestStats = function getRequestStats(request) {
2441  return {
2442    bandwidth: request.bandwidth,
2443    bytesReceived: request.bytesReceived || 0,
2444    roundTripTime: request.roundTripTime || 0
2445  };
2446};
2447
2448/**
2449 * If possible gather bandwidth stats as a request is in
2450 * progress
2451 *
2452 * @param {Event} progressEvent - an event object from an XHR's progress event
2453 */
2454var getProgressStats = function getProgressStats(progressEvent) {
2455  var request = progressEvent.target;
2456  var roundTripTime = Date.now() - request.requestTime;
2457  var stats = {
2458    bandwidth: Infinity,
2459    bytesReceived: 0,
2460    roundTripTime: roundTripTime || 0
2461  };
2462
2463  stats.bytesReceived = progressEvent.loaded;
2464  // This can result in Infinity if stats.roundTripTime is 0 but that is ok
2465  // because we should only use bandwidth stats on progress to determine when
2466  // abort a request early due to insufficient bandwidth
2467  stats.bandwidth = Math.floor(stats.bytesReceived / stats.roundTripTime * 8 * 1000);
2468
2469  return stats;
2470};
2471
2472/**
2473 * Handle all error conditions in one place and return an object
2474 * with all the information
2475 *
2476 * @param {Error|null} error - if non-null signals an error occured with the XHR
2477 * @param {Object} request -  the XHR request that possibly generated the error
2478 */
2479var handleErrors = function handleErrors(error, request) {
2480  if (request.timedout) {
2481    return {
2482      status: request.status,
2483      message: 'HLS request timed-out at URL: ' + request.uri,
2484      code: REQUEST_ERRORS.TIMEOUT,
2485      xhr: request
2486    };
2487  }
2488
2489  if (request.aborted) {
2490    return {
2491      status: request.status,
2492      message: 'HLS request aborted at URL: ' + request.uri,
2493      code: REQUEST_ERRORS.ABORTED,
2494      xhr: request
2495    };
2496  }
2497
2498  if (error) {
2499    return {
2500      status: request.status,
2501      message: 'HLS request errored at URL: ' + request.uri,
2502      code: REQUEST_ERRORS.FAILURE,
2503      xhr: request
2504    };
2505  }
2506
2507  return null;
2508};
2509
2510/**
2511 * Handle responses for key data and convert the key data to the correct format
2512 * for the decryption step later
2513 *
2514 * @param {Object} segment - a simplified copy of the segmentInfo object
2515 *                           from SegmentLoader
2516 * @param {Function} finishProcessingFn - a callback to execute to continue processing
2517 *                                        this request
2518 */
2519var handleKeyResponse = function handleKeyResponse(segment, finishProcessingFn) {
2520  return function (error, request) {
2521    var response = request.response;
2522    var errorObj = handleErrors(error, request);
2523
2524    if (errorObj) {
2525      return finishProcessingFn(errorObj, segment);
2526    }
2527
2528    if (response.byteLength !== 16) {
2529      return finishProcessingFn({
2530        status: request.status,
2531        message: 'Invalid HLS key at URL: ' + request.uri,
2532        code: REQUEST_ERRORS.FAILURE,
2533        xhr: request
2534      }, segment);
2535    }
2536
2537    var view = new DataView(response);
2538
2539    segment.key.bytes = new Uint32Array([view.getUint32(0), view.getUint32(4), view.getUint32(8), view.getUint32(12)]);
2540    return finishProcessingFn(null, segment);
2541  };
2542};
2543
2544/**
2545 * Handle init-segment responses
2546 *
2547 * @param {Object} segment - a simplified copy of the segmentInfo object
2548 *                           from SegmentLoader
2549 * @param {Function} finishProcessingFn - a callback to execute to continue processing
2550 *                                        this request
2551 */
2552var handleInitSegmentResponse = function handleInitSegmentResponse(segment, finishProcessingFn) {
2553  return function (error, request) {
2554    var response = request.response;
2555    var errorObj = handleErrors(error, request);
2556
2557    if (errorObj) {
2558      return finishProcessingFn(errorObj, segment);
2559    }
2560
2561    // stop processing if received empty content
2562    if (response.byteLength === 0) {
2563      return finishProcessingFn({
2564        status: request.status,
2565        message: 'Empty HLS segment content at URL: ' + request.uri,
2566        code: REQUEST_ERRORS.FAILURE,
2567        xhr: request
2568      }, segment);
2569    }
2570
2571    segment.map.bytes = new Uint8Array(request.response);
2572    return finishProcessingFn(null, segment);
2573  };
2574};
2575
2576/**
2577 * Response handler for segment-requests being sure to set the correct

2578 * property depending on whether the segment is encryped or not
2579 * Also records and keeps track of stats that are used for ABR purposes
2580 *
2581 * @param {Object} segment - a simplified copy of the segmentInfo object
2582 *                           from SegmentLoader
2583 * @param {Function} finishProcessingFn - a callback to execute to continue processing
2584 *                                        this request
2585 */
2586var handleSegmentResponse = function handleSegmentResponse(segment, finishProcessingFn) {
2587  return function (error, request) {
2588    var response = request.response;
2589    var errorObj = handleErrors(error, request);
2590
2591    if (errorObj) {
2592      return finishProcessingFn(errorObj, segment);
2593    }
2594
2595    // stop processing if received empty content
2596    if (response.byteLength === 0) {
2597      return finishProcessingFn({
2598        status: request.status,
2599        message: 'Empty HLS segment content at URL: ' + request.uri,
2600        code: REQUEST_ERRORS.FAILURE,
2601        xhr: request
2602      }, segment);
2603    }
2604
2605    segment.stats = getRequestStats(request);
2606
2607    if (segment.key) {
2608      segment.encryptedBytes = new Uint8Array(request.response);
2609    } else {
2610      segment.bytes = new Uint8Array(request.response);
2611    }
2612
2613    return finishProcessingFn(null, segment);
2614  };
2615};
2616
2617/**
2618 * Decrypt the segment via the decryption web worker
2619 *
2620 * @param {WebWorker} decrypter - a WebWorker interface to AES-128 decryption routines
2621 * @param {Object} segment - a simplified copy of the segmentInfo object
2622 *                           from SegmentLoader
2623 * @param {Function} doneFn - a callback that is executed after decryption has completed
2624 */
2625var decryptSegment = function decryptSegment(decrypter, segment, doneFn) {
2626  var decryptionHandler = function decryptionHandler(event) {
2627    if (event.data.source === segment.requestId) {
2628      decrypter.removeEventListener('message', decryptionHandler);
2629      var decrypted = event.data.decrypted;
2630
2631      segment.bytes = new Uint8Array(decrypted.bytes, decrypted.byteOffset, decrypted.byteLength);
2632      return doneFn(null, segment);
2633    }
2634  };
2635
2636  decrypter.addEventListener('message', decryptionHandler);
2637
2638  // this is an encrypted segment
2639  // incrementally decrypt the segment
2640  decrypter.postMessage((0, _binUtils.createTransferableMessage)({
2641    source: segment.requestId,
2642    encrypted: segment.encryptedBytes,
2643    key: segment.key.bytes,
2644    iv: segment.key.iv
2645  }), [segment.encryptedBytes.buffer, segment.key.bytes.buffer]);
2646};
2647
2648/**
2649 * The purpose of this function is to get the most pertinent error from the
2650 * array of errors.
2651 * For instance if a timeout and two aborts occur, then the aborts were
2652 * likely triggered by the timeout so return that error object.
2653 */
2654var getMostImportantError = function getMostImportantError(errors) {
2655  return errors.reduce(function (prev, err) {
2656    return err.code > prev.code ? err : prev;
2657  });
2658};
2659
2660/**
2661 * This function waits for all XHRs to finish (with either success or failure)
2662 * before continueing processing via it's callback. The function gathers errors
2663 * from each request into a single errors array so that the error status for
2664 * each request can be examined later.
2665 *
2666 * @param {Object} activeXhrs - an object that tracks all XHR requests
2667 * @param {WebWorker} decrypter - a WebWorker interface to AES-128 decryption routines
2668 * @param {Function} doneFn - a callback that is executed after all resources have been
2669 *                            downloaded and any decryption completed
2670 */
2671var waitForCompletion = function waitForCompletion(activeXhrs, decrypter, doneFn) {
2672  var errors = [];
2673  var count = 0;
2674
2675  return function (error, segment) {
2676    if (error) {
2677      // If there are errors, we have to abort any outstanding requests
2678      abortAll(activeXhrs);
2679      errors.push(error);
2680    }
2681    count += 1;
2682
2683    if (count === activeXhrs.length) {
2684      // Keep track of when *all* of the requests have completed
2685      segment.endOfAllRequests = Date.now();
2686
2687      if (errors.length > 0) {
2688        var worstError = getMostImportantError(errors);
2689
2690        return doneFn(worstError, segment);
2691      }
2692      if (segment.encryptedBytes) {
2693        return decryptSegment(decrypter, segment, doneFn);
2694      }
2695      // Otherwise, everything is ready just continue
2696      return doneFn(null, segment);
2697    }
2698  };
2699};
2700
2701/**
2702 * Simple progress event callback handler that gathers some stats before
2703 * executing a provided callback with the `segment` object
2704 *
2705 * @param {Object} segment - a simplified copy of the segmentInfo object
2706 *                           from SegmentLoader
2707 * @param {Function} progressFn - a callback that is executed each time a progress event
2708 *                                is received
2709 * @param {Event} event - the progress event object from XMLHttpRequest
2710 */
2711var handleProgress = function handleProgress(segment, progressFn) {
2712  return function (event) {
2713    segment.stats = _videoJs2['default'].mergeOptions(segment.stats, getProgressStats(event));
2714
2715    // record the time that we receive the first byte of data
2716    if (!segment.stats.firstBytesReceivedAt && segment.stats.bytesReceived) {
2717      segment.stats.firstBytesReceivedAt = Date.now();
2718    }
2719
2720    return progressFn(event, segment);
2721  };
2722};
2723
2724/**
2725 * Load all resources and does any processing necessary for a media-segment
2726 *
2727 * Features:
2728 *   decrypts the media-segment if it has a key uri and an iv
2729 *   aborts *all* requests if *any* one request fails
2730 *
2731 * The segment object, at minimum, has the following format:
2732 * {
2733 *   resolvedUri: String,
2734 *   [byterange]: {
2735 *     offset: Number,
2736 *     length: Number
2737 *   },
2738 *   [key]: {
2739 *     resolvedUri: String
2740 *     [byterange]: {
2741 *       offset: Number,
2742 *       length: Number
2743 *     },
2744 *     iv: {
2745 *       bytes: Uint32Array
2746 *     }
2747 *   },
2748 *   [map]: {
2749 *     resolvedUri: String,
2750 *     [byterange]: {
2751 *       offset: Number,
2752 *       length: Number
2753 *     },
2754 *     [bytes]: Uint8Array
2755 *   }
2756 * }
2757 * ...where [name] denotes optional properties
2758 *
2759 * @param {Function} xhr - an instance of the xhr wrapper in xhr.js
2760 * @param {Object} xhrOptions - the base options to provide to all xhr requests
2761 * @param {WebWorker} decryptionWorker - a WebWorker interface to AES-128
2762 *                                       decryption routines
2763 * @param {Object} segment - a simplified copy of the segmentInfo object
2764 *                           from SegmentLoader
2765 * @param {Function} progressFn - a callback that receives progress events from the main
2766 *                                segment's xhr request
2767 * @param {Function} doneFn - a callback that is executed only once all requests have
2768 *                            succeeded or failed
2769 * @returns {Function} a function that, when invoked, immediately aborts all
2770 *                     outstanding requests
2771 */
2772var mediaSegmentRequest = function mediaSegmentRequest(xhr, xhrOptions, decryptionWorker, segment, progressFn, doneFn) {
2773  var activeXhrs = [];