Source: lib/player.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.Player');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.abr.SimpleAbrManager');
  22. goog.require('shaka.log');
  23. goog.require('shaka.media.DrmEngine');
  24. goog.require('shaka.media.ManifestParser');
  25. goog.require('shaka.media.MediaSourceEngine');
  26. goog.require('shaka.media.Playhead');
  27. goog.require('shaka.media.SegmentReference');
  28. goog.require('shaka.media.StreamingEngine');
  29. goog.require('shaka.net.NetworkingEngine');
  30. goog.require('shaka.util.CancelableChain');
  31. goog.require('shaka.util.ConfigUtils');
  32. goog.require('shaka.util.Error');
  33. goog.require('shaka.util.EventManager');
  34. goog.require('shaka.util.FakeEvent');
  35. goog.require('shaka.util.FakeEventTarget');
  36. goog.require('shaka.util.IDestroyable');
  37. goog.require('shaka.util.MapUtils');
  38. goog.require('shaka.util.PublicPromise');
  39. goog.require('shaka.util.StreamUtils');
  43. /**
  44.  * Construct a Player.
  45.  *
  46.  * @param {!HTMLMediaElement} video Any existing TextTracks attached to this
  47.  *   element that were not created by Shaka will be disabled.  A new TextTrack
  48.  *   may be created to display captions or subtitles.
  49.  * @param {function(shaka.Player)=} opt_dependencyInjector Optional callback
  50.  *   which is called to inject mocks into the Player. Used for testing.
  51.  *
  52.  * @constructor
  53.  * @struct
  54.  * @implements {shaka.util.IDestroyable}
  55.  * @extends {shaka.util.FakeEventTarget}
  56.  * @export
  57.  */
  58. shaka.Player = function(video, opt_dependencyInjector) {
  59.   shaka.util.FakeEventTarget.call(this);
  61.   /** @private {boolean} */
  62.   this.destroyed_ = false;
  64.   /** @private {HTMLMediaElement} */
  65.   this.video_ = video;
  67.   /** @private {TextTrack} */
  68.   this.textTrack_ = null;
  70.   /** @private {shaka.util.EventManager} */
  71.   this.eventManager_ = new shaka.util.EventManager();
  73.   /** @private {shakaExtern.AbrManager} */
  74.   this.defaultAbrManager_ = new shaka.abr.SimpleAbrManager();
  76.   /** @private {shaka.net.NetworkingEngine} */
  77.   this.networkingEngine_ = null;
  79.   /** @private {shaka.media.DrmEngine} */
  80.   this.drmEngine_ = null;
  82.   /** @private {MediaSource} */
  83.   this.mediaSource_ = null;
  85.   /** @private {shaka.media.MediaSourceEngine} */
  86.   this.mediaSourceEngine_ = null;
  88.   /** @private {Promise} */
  89.   this.mediaSourceOpen_ = null;
  91.   /** @private {shaka.media.Playhead} */
  92.   this.playhead_ = null;
  94.   /** @private {shaka.media.StreamingEngine} */
  95.   this.streamingEngine_ = null;
  97.   /** @private {shakaExtern.ManifestParser} */
  98.   this.parser_ = null;
  100.   /** @private {?shakaExtern.Manifest} */
  101.   this.manifest_ = null;
  103.   /** @private {?string} */
  104.   this.manifestUri_ = null;
  106.   /**
  107.    * Contains an ID for use with creating streams.  The manifest parser should
  108.    * start with small IDs, so this starts with a large one.
  109.    * @private {number}
  110.    */
  111.   this.nextExternalStreamId_ = 1e9;
  113.   /** @private {!Array.<number>} */
  114.   this.loadingTextStreamIds_ = [];
  116.   /** @private {boolean} */
  117.   this.buffering_ = false;
  119.   /** @private {boolean} */
  120.   this.switchingPeriods_ = true;
  122.   /** @private {shaka.util.CancelableChain} */
  123.   this.loadChain_ = null;
  125.   /**
  126.    * @private {!Object.<string, {stream: shakaExtern.Stream, clear: boolean}>}
  127.    */
  128.   this.deferredSwitches_ = {};
  130.   /** @private {?shakaExtern.PlayerConfiguration} */
  131.   this.config_ = this.defaultConfig_();
  133.   /** @private {{width: number, height: number}} */
  134.   this.maxHwRes_ = { width: Infinity, height: Infinity };
  136.   /** @private {!Array.<shakaExtern.StreamChoice>} */
  137.   this.switchHistory_ = [];
  139.   /** @private {number} */
  140.   this.playTime_ = 0;
  142.   /** @private {number} */
  143.   this.bufferingTime_ = 0;
  145.   /** @private {number} */
  146.   this.lastStatUpdateTimestamp_ = 0;
  148.   if (opt_dependencyInjector)
  149.     opt_dependencyInjector(this);
  151.   this.networkingEngine_ = this.createNetworkingEngine();
  152.   this.initialize_();
  153. };
  154. goog.inherits(shaka.Player, shaka.util.FakeEventTarget);
  157. /**
  158.  * After destruction, a Player object cannot be used again.
  159.  *
  160.  * @override
  161.  * @export
  162.  */
  163. shaka.Player.prototype.destroy = function() {
  164.   this.destroyed_ = true;
  166.   var cancelation = Promise.resolve();
  167.   if (this.loadChain_) {
  168.     // A load is in progress.  Cancel it.
  169.     cancelation = this.loadChain_.cancel(new shaka.util.Error(
  170.         shaka.util.Error.Category.PLAYER,
  171.         shaka.util.Error.Code.LOAD_INTERRUPTED));
  172.   }
  174.   return cancelation.then(function() {
  175.     var p = Promise.all([
  176.       this.destroyStreaming_(),
  177.       this.eventManager_ ? this.eventManager_.destroy() : null,
  178.       this.networkingEngine_ ? this.networkingEngine_.destroy() : null
  179.     ]);
  181.     this.video_ = null;
  182.     this.textTrack_ = null;
  183.     this.eventManager_ = null;
  184.     this.defaultAbrManager_ = null;
  185.     this.networkingEngine_ = null;
  186.     this.config_ = null;
  188.     return p;
  189.   }.bind(this));
  190. };
  193. /**
  194.  * @define {string} A version number taken from git at compile time.
  195.  */
  196. goog.define('GIT_VERSION', 'v2.0.0-debug');
  199. /**
  200.  * @const {string}
  201.  * @export
  202.  */
  203. shaka.Player.version = GIT_VERSION;
  206. /**
  207.  * @event shaka.Player.ErrorEvent
  208.  * @description Fired when a playback error occurs.
  209.  * @property {string} type
  210.  *   'error'
  211.  * @property {!shaka.util.Error} detail
  212.  *   An object which contains details on the error.  The error's 'category' and
  213.  *   'code' properties will identify the specific error that occured.  In an
  214.  *   uncompiled build, you can also use the 'message' and 'stack' properties
  215.  *   to debug.
  216.  * @exportDoc
  217.  */
  220. /**
  221.  * @event shaka.Player.EmsgEvent
  222.  * @description Fired when a non-typical emsg is found in a segment.
  223.  * @property {string} type
  224.  *   'emsg'
  225.  * @property {!shaka.dash.DashParser.EmsgInfo} detail
  226.  *   An object which contains the content of the emsg box.
  227.  * @exportDoc
  228.  */
  231. /**
  232.  * @event shaka.Player.BufferingEvent
  233.  * @description Fired when the player's buffering state changes.
  234.  * @property {string} type
  235.  *   'buffering'
  236.  * @property {boolean} buffering
  237.  *   True when the Player enters the buffering state.
  238.  *   False when the Player leaves the buffering state.
  239.  * @exportDoc
  240.  */
  243. /**
  244.  * @event shaka.Player.LoadingEvent
  245.  * @description Fired when the player begins loading.
  246.  *   Used by the Cast receiver to determine idle state.
  247.  * @property {string} type
  248.  *   'loading'
  249.  * @exportDoc
  250.  */
  253. /**
  254.  * @event shaka.Player.UnloadingEvent
  255.  * @description Fired when the player unloads or fails to load.
  256.  *   Used by the Cast receiver to determine idle state.
  257.  * @property {string} type
  258.  *   'unloading'
  259.  * @exportDoc
  260.  */
  263. /**
  264.  * @event shaka.Player.TextTrackVisibilityEvent
  265.  * @description Fired when text track visibility changes.
  266.  * @property {string} type
  267.  *   'texttrackvisibility'
  268.  * @exportDoc
  269.  */
  272. /**
  273.  * @event shaka.Player.TracksChangedEvent
  274.  * @description Fired when the list of tracks changes.  For example, this will
  275.  *   happen when changing periods or when track restrictions change.
  276.  * @property {string} type
  277.  *   'trackschanged'
  278.  * @exportDoc
  279.  */
  282. /**
  283.  * @event shaka.Player.AdaptationEvent
  284.  * @description Fired when an automatic adaptation causes the active tracks
  285.  *   to change.  Does not fire when the application calls selectTrack().
  286.  * @property {string} type
  287.  *   'adaptation'
  288.  * @exportDoc
  289.  */
  292. /** @private {!Object.<string, function():*>} */
  293. shaka.Player.supportPlugins_ = {};
  296. /**
  297.  * Registers a plugin callback that will be called with support().  The
  298.  * callback will return the value that will be stored in the return value from
  299.  * support().
  300.  *
  301.  * @param {string} name
  302.  * @param {function():*} callback
  303.  * @export
  304.  */
  305. shaka.Player.registerSupportPlugin = function(name, callback) {
  306.   shaka.Player.supportPlugins_[name] = callback;
  307. };
  310. /**
  311.  * Return whether the browser provides basic support. If this returns false,
  312.  * Shaka Player cannot be used at all. In this case, do not construct a Player
  313.  * instance and do not use the library.
  314.  *
  315.  * @return {boolean}
  316.  * @export
  317.  */
  318. shaka.Player.isBrowserSupported = function() {
  319.   // Basic features needed for the library to be usable.
  320.   var basic = !!window.Promise && !!window.Uint8Array &&
  321.               !!Array.prototype.forEach;
  323.   return basic &&
  324.       shaka.media.MediaSourceEngine.isBrowserSupported() &&
  325.       shaka.media.DrmEngine.isBrowserSupported();
  326. };
  329. /**
  330.  * Probes the browser to determine what features are supported.  This makes a
  331.  * number of requests to EME/MSE/etc which may result in user prompts.  This
  332.  * should only be used for diagnostics.
  333.  *
  334.  * NOTE: This may show a request to the user for permission.
  335.  *
  336.  * @see https://goo.gl/ovYLvl
  337.  * @return {!Promise.<shakaExtern.SupportType>}
  338.  * @export
  339.  */
  340. shaka.Player.probeSupport = function() {
  341.   goog.asserts.assert(shaka.Player.isBrowserSupported(),
  342.                       'Must have basic support');
  343.   return shaka.media.DrmEngine.probeSupport().then(function(drm) {
  344.     var manifest = shaka.media.ManifestParser.probeSupport();
  345.     var media = shaka.media.MediaSourceEngine.probeSupport();
  346.     var ret = {
  347.       manifest: manifest,
  348.       media: media,
  349.       drm: drm
  350.     };
  352.     var plugins = shaka.Player.supportPlugins_;
  353.     for (var name in plugins) {
  354.       ret[name] = plugins[name]();
  355.     }
  357.     return ret;
  358.   });
  359. };
  362. /**
  363.  * Load a manifest.
  364.  *
  365.  * @param {string} manifestUri
  366.  * @param {number=} opt_startTime Optional start time, in seconds, to begin
  367.  *   playback.  Defaults to 0 for VOD and to the live edge for live.
  368.  * @param {shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  369.  *   Optional manifest parser factory to override auto-detection or use an
  370.  *   unregistered parser.
  371.  * @return {!Promise} Resolved when the manifest has been loaded and playback
  372.  *   has begun; rejected when an error occurs or the call was interrupted by
  373.  *   destroy(), unload() or another call to load().
  374.  * @export
  375.  */
  376. shaka.Player.prototype.load = function(manifestUri, opt_startTime,
  377.                                        opt_manifestParserFactory) {
  378.   var unloadPromise = this.unload();
  379.   var loadChain = new shaka.util.CancelableChain();
  380.   this.loadChain_ = loadChain;
  381.   this.dispatchEvent(new shaka.util.FakeEvent('loading'));
  383.   return loadChain.then(function() {
  384.     return unloadPromise;
  385.   }).then(function() {
  387.     goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  388.     return shaka.media.ManifestParser.getFactory(
  389.         manifestUri,
  390.         this.networkingEngine_,
  391.         this.config_.manifest.retryParameters,
  392.         opt_manifestParserFactory);
  393.   }.bind(this)).then(function(factory) {
  395.     this.parser_ = new factory();
  396.     this.parser_.configure(this.config_.manifest);
  397.     goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  398.     return this.parser_.start(
  399.         manifestUri,
  400.         this.networkingEngine_,
  401.         this.filterPeriod_.bind(this),
  402.         this.onError_.bind(this),
  403.         this.onEvent_.bind(this));
  404.   }.bind(this)).then(function(manifest) {
  406.     this.manifest_ = manifest;
  407.     this.manifestUri_ = manifestUri;
  408.     this.drmEngine_ = this.createDrmEngine();
  409.     this.drmEngine_.configure(this.config_.drm);
  410.     return this.drmEngine_.init(manifest, false /* isOffline */);
  411.   }.bind(this)).then(function() {
  413.     // Re-filter the manifest after DRM has been initialized.
  414.     this.manifest_.periods.forEach(this.filterPeriod_.bind(this));
  416.     this.lastStatUpdateTimestamp_ = Date.now() / 1000;
  418.     // Wait for MediaSource to open before continuing.
  419.     return Promise.all([
  420.       this.drmEngine_.attach(this.video_),
  421.       this.mediaSourceOpen_
  422.     ]);
  423.   }.bind(this)).then(function() {
  425.     // MediaSource is open, so create the Playhead, MediaSourceEngine, and
  426.     // StreamingEngine.
  427.     this.playhead_ = this.createPlayhead(opt_startTime);
  428.     this.mediaSourceEngine_ = this.createMediaSourceEngine();
  430.     this.streamingEngine_ = this.createStreamingEngine();
  431.     this.streamingEngine_.configure(this.config_.streaming);
  432.     return this.streamingEngine_.init();
  433.   }.bind(this)).then(function() {
  435.     // Re-filter the manifest after streams have been chosen.
  436.     this.manifest_.periods.forEach(this.filterPeriod_.bind(this));
  437.     // Dispatch a 'trackschanged' event now that all initial filtering is done.
  438.     this.onTracksChanged_();
  439.     // Since the first streams just became active, send an adaptation event.
  440.     this.onAdaptation_();
  442.     this.config_.abr.manager.init(this.switch_.bind(this));
  444.     this.loadChain_ = null;
  445.   }.bind(this)).finalize().catch(function(error) {
  446.     goog.asserts.assert(error instanceof shaka.util.Error,
  447.                         'Wrong error type!');
  448.     shaka.log.debug('load() failed:', error);
  450.     // If we haven't started another load, clear the loadChain_ member.
  451.     if (this.loadChain_ == loadChain) {
  452.       this.loadChain_ = null;
  453.       this.dispatchEvent(new shaka.util.FakeEvent('unloading'));
  454.     }
  455.     return Promise.reject(error);
  456.   }.bind(this));
  457. };
  460. /**
  461.  * Creates a new instance of DrmEngine.  This can be replaced by tests to
  462.  * create fake instances instead.
  463.  *
  464.  * @return {!shaka.media.DrmEngine}
  465.  */
  466. shaka.Player.prototype.createDrmEngine = function() {
  467.   goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  468.   return new shaka.media.DrmEngine(
  469.       this.networkingEngine_,
  470.       this.onError_.bind(this),
  471.       this.onKeyStatus_.bind(this));
  472. };
  475. /**
  476.  * Creates a new instance of NetworkingEngine.  This can be replaced by tests
  477.  * to create fake instances instead.
  478.  *
  479.  * @return {!shaka.net.NetworkingEngine}
  480.  */
  481. shaka.Player.prototype.createNetworkingEngine = function() {
  482.   return new shaka.net.NetworkingEngine(this.onSegmentDownloaded_.bind(this));
  483. };
  486. /**
  487.  * Creates a new instance of Playhead.  This can be replaced by tests to create
  488.  * fake instances instead.
  489.  *
  490.  * @param {number=} opt_startTime
  491.  * @return {!shaka.media.Playhead}
  492.  */
  493. shaka.Player.prototype.createPlayhead = function(opt_startTime) {
  494.   var timeline = this.manifest_.presentationTimeline;
  495.   var rebufferingGoal = shaka.media.StreamingEngine.getRebufferingGoal(
  496.       this.manifest_, this.config_.streaming, 1 /* scaleFactor */);
  497.   return new shaka.media.Playhead(
  498.       this.video_, timeline, rebufferingGoal, opt_startTime || null,
  499.       this.onBuffering_.bind(this), this.onSeek_.bind(this));
  500. };
  503. /**
  504.  * Create and open MediaSource.  Potentially slow.
  505.  *
  506.  * @return {!Promise}
  507.  */
  508. shaka.Player.prototype.createMediaSource = function() {
  509.   this.mediaSource_ = new MediaSource();
  510.   var ret = new shaka.util.PublicPromise();
  511.   this.eventManager_.listen(this.mediaSource_, 'sourceopen', ret.resolve);
  512.   this.video_.src = window.URL.createObjectURL(this.mediaSource_);
  513.   return ret;
  514. };
  517. /**
  518.  * Creates a new instance of MediaSourceEngine.  This can be replaced by tests
  519.  * to create fake instances instead.
  520.  *
  521.  * @return {!shaka.media.MediaSourceEngine}
  522.  */
  523. shaka.Player.prototype.createMediaSourceEngine = function() {
  524.   return new shaka.media.MediaSourceEngine(
  525.       this.video_, this.mediaSource_, this.textTrack_);
  526. };
  529. /**
  530.  * Creates a new instance of StreamingEngine.  This can be replaced by tests
  531.  * to create fake instances instead.
  532.  *
  533.  * @return {!shaka.media.StreamingEngine}
  534.  */
  535. shaka.Player.prototype.createStreamingEngine = function() {
  536.   goog.asserts.assert(this.playhead_, 'Must not be destroyed');
  537.   goog.asserts.assert(this.mediaSourceEngine_, 'Must not be destroyed');
  538.   goog.asserts.assert(this.manifest_, 'Must not be destroyed');
  539.   return new shaka.media.StreamingEngine(
  540.       this.playhead_, this.mediaSourceEngine_, this.networkingEngine_,
  541.       this.manifest_, this.onChooseStreams_.bind(this),
  542.       this.canSwitch_.bind(this), this.onError_.bind(this));
  543. };
  546. /**
  547.  * Configure the Player instance.
  548.  *
  549.  * The config object passed in need not be complete.  It will be merged with
  550.  * the existing Player configuration.
  551.  *
  552.  * Config keys and types will be checked.  If any problems with the config
  553.  * object are found, errors will be reported through logs.
  554.  *
  555.  * @param {shakaExtern.PlayerConfiguration} config
  556.  * @export
  557.  */
  558. shaka.Player.prototype.configure = function(config) {
  559.   goog.asserts.assert(this.config_, 'Config must not be null!');
  561.   if (config.abr && config.abr.manager &&
  562.       config.abr.manager != this.config_.abr.manager) {
  563.     this.config_.abr.manager.stop();
  564.     config.abr.manager.init(this.switch_.bind(this));
  565.   }
  567.   shaka.util.ConfigUtils.mergeConfigObjects(
  568.       this.config_, config, this.defaultConfig_(), this.configOverrides_(), '');
  570.   this.applyConfig_();
  571. };
  574. /**
  575.  * Apply config changes.
  576.  * @private
  577.  */
  578. shaka.Player.prototype.applyConfig_ = function() {
  579.   if (this.parser_) {
  580.     this.parser_.configure(this.config_.manifest);
  581.   }
  582.   if (this.drmEngine_) {
  583.     this.drmEngine_.configure(this.config_.drm);
  584.   }
  585.   if (this.streamingEngine_) {
  586.     this.streamingEngine_.configure(this.config_.streaming);
  588.     // Need to apply the restrictions to every period.
  589.     this.manifest_.periods.forEach(this.filterPeriod_.bind(this));
  591.     // May need to choose new streams.
  592.     shaka.log.debug('Choosing new streams after changing configuration');
  593.     var period = this.streamingEngine_.getCurrentPeriod();
  594.     this.chooseStreamsAndSwitch_(period);
  595.   }
  597.   // Simply enable/disable ABR with each call, since multiple calls to these
  598.   // methods have no effect.
  599.   if (this.config_.abr.enabled && !this.switchingPeriods_) {
  600.     this.config_.abr.manager.enable();
  601.   } else {
  602.     this.config_.abr.manager.disable();
  603.   }
  605.   this.config_.abr.manager.setDefaultEstimate(
  606.       this.config_.abr.defaultBandwidthEstimate);
  607. };
  610. /**
  611.  * Return a copy of the current configuration.  Modifications of the returned
  612.  * value will not affect the Player's active configuration.  You must call
  613.  * player.configure() to make changes.
  614.  *
  615.  * @return {shakaExtern.PlayerConfiguration}
  616.  * @export
  617.  */
  618. shaka.Player.prototype.getConfiguration = function() {
  619.   goog.asserts.assert(this.config_, 'Config must not be null!');
  621.   var ret = this.defaultConfig_();
  622.   shaka.util.ConfigUtils.mergeConfigObjects(
  623.       ret, this.config_, this.defaultConfig_(), this.configOverrides_(), '');
  624.   return ret;
  625. };
  628. /**
  629.  * Reset configuration to default.
  630.  * @export
  631.  */
  632. shaka.Player.prototype.resetConfiguration = function() {
  633.   var config = this.defaultConfig_();
  635.   if (config.abr && config.abr.manager &&
  636.       config.abr.manager != this.config_.abr.manager) {
  637.     this.config_.abr.manager.stop();
  638.     config.abr.manager.init(this.switch_.bind(this));
  639.   }
  641.   // Don't call mergeConfigObjects_(), since that would not reset open-ended
  642.   // dictionaries like drm.servers.
  643.   this.config_ = this.defaultConfig_();
  645.   this.applyConfig_();
  646. };
  649. /**
  650.  * @return {shaka.net.NetworkingEngine} A reference to the Player's networking
  651.  *     engine.  Applications may use this to make requests through Shaka's
  652.  *     networking plugins.
  653.  * @export
  654.  */
  655. shaka.Player.prototype.getNetworkingEngine = function() {
  656.   return this.networkingEngine_;
  657. };
  660. /**
  661.  * @return {?string} If a manifest is loaded, returns the manifest URI given in
  662.  *   the last call to load().  Otherwise, returns null.
  663.  * @export
  664.  */
  665. shaka.Player.prototype.getManifestUri = function() {
  666.   return this.manifestUri_;
  667. };
  670. /**
  671.  * @return {boolean} True if the current stream is live.  False otherwise.
  672.  * @export
  673.  */
  674. shaka.Player.prototype.isLive = function() {
  675.   return this.manifest_ ?
  676.          this.manifest_.presentationTimeline.isLive() :
  677.          false;
  678. };
  681. /**
  682.  * @return {boolean} True if the current stream is in-progress VOD.
  683.  *   False otherwise.
  684.  * @export
  685.  */
  686. shaka.Player.prototype.isInProgress = function() {
  687.   return this.manifest_ ?
  688.          this.manifest_.presentationTimeline.isInProgress() :
  689.          false;
  690. };
  693. /**
  694.  * Get the seekable range for the current stream.
  695.  * @return {{start: number, end: number}}
  696.  * @export
  697.  */
  698. shaka.Player.prototype.seekRange = function() {
  699.   var start = 0;
  700.   var end = 0;
  701.   if (this.manifest_) {
  702.     var timeline = this.manifest_.presentationTimeline;
  703.     start = timeline.getSegmentAvailabilityStart();
  704.     end = timeline.getSeekRangeEnd();
  705.   }
  706.   return {'start': start, 'end': end};
  707. };
  710. /**
  711.  * Get the key system currently being used by EME.  This returns the empty
  712.  * string if not using EME.
  713.  *
  714.  * @return {string}
  715.  * @export
  716.  */
  717. shaka.Player.prototype.keySystem = function() {
  718.   return this.drmEngine_ ? this.drmEngine_.keySystem() : '';
  719. };
  722. /**
  723.  * Get the DrmInfo used to initialize EME.  This returns null when not using
  724.  * EME.
  725.  *
  726.  * @return {?shakaExtern.DrmInfo}
  727.  * @export
  728.  */
  729. shaka.Player.prototype.drmInfo = function() {
  730.   return this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  731. };
  734. /**
  735.  * @return {boolean} True if the Player is in a buffering state.
  736.  * @export
  737.  */
  738. shaka.Player.prototype.isBuffering = function() {
  739.   return this.buffering_;
  740. };
  743. /**
  744.  * Unload the current manifest and make the Player available for re-use.
  745.  *
  746.  * @return {!Promise} Resolved when streaming has stopped and the previous
  747.  *     content, if any, has been unloaded.
  748.  * @export
  749.  */
  750. shaka.Player.prototype.unload = function() {
  751.   if (this.destroyed_) return Promise.resolve();
  752.   this.dispatchEvent(new shaka.util.FakeEvent('unloading'));
  754.   if (this.loadChain_) {
  755.     // A load is in progress.  Cancel it, then reset the streaming system.
  756.     var interrupt = new shaka.util.Error(
  757.         shaka.util.Error.Category.PLAYER,
  758.         shaka.util.Error.Code.LOAD_INTERRUPTED);
  759.     return this.loadChain_.cancel(interrupt)
  760.         .then(this.resetStreaming_.bind(this));
  761.   } else {
  762.     // No loads or unloads are in progress.
  763.     // Just reset the streaming system if needed.
  764.     return this.resetStreaming_();
  765.   }
  766. };
  769. /**
  770.  * Gets the current effective playback rate.  If using trick play, it will
  771.  * return the current trick play rate; otherwise, it will return the video
  772.  * playback rate.
  773.  * @return {number}
  774.  * @export
  775.  */
  776. shaka.Player.prototype.getPlaybackRate = function() {
  777.   return this.playhead_ ? this.playhead_.getPlaybackRate() : 0;
  778. };
  781. /**
  782.  * Skip through the content without playing.  Simulated using repeated seeks.
  783.  *
  784.  * Trick play will be canceled automatically if the playhead hits the beginning
  785.  * or end of the seekable range for the content.
  786.  *
  787.  * @param {number} rate The playback rate to simulate.  For example, a rate of
  788.  *     2.5 would result in 2.5 seconds of content being skipped every second.
  789.  *     To trick-play backward, use a negative rate.
  790.  * @export
  791.  */
  792. shaka.Player.prototype.trickPlay = function(rate) {
  793.   if (this.playhead_)
  794.     this.playhead_.setPlaybackRate(rate);
  795. };
  798. /**
  799.  * Cancel trick-play.
  800.  * @export
  801.  */
  802. shaka.Player.prototype.cancelTrickPlay = function() {
  803.   if (this.playhead_)
  804.     this.playhead_.setPlaybackRate(1);
  805. };
  808. /**
  809.  * Return a list of audio, video, and text tracks available for the current
  810.  * Period.  If there are multiple Periods, then you must seek to the Period
  811.  * before being able to switch.
  812.  *
  813.  * @return {!Array.<shakaExtern.Track>}
  814.  * @export
  815.  */
  816. shaka.Player.prototype.getTracks = function() {
  817.   if (!this.streamingEngine_)
  818.     return [];
  820.   var activeStreams = this.streamingEngine_.getActiveStreams();
  821.   var period = this.streamingEngine_.getCurrentPeriod();
  822.   return shaka.util.StreamUtils.getTracks(period, activeStreams)
  823.       .filter(function(track) {
  824.         // Don't show any tracks that are being loaded still.
  825.         return this.loadingTextStreamIds_.indexOf(track.id) < 0;
  826.       }.bind(this));
  827. };
  830. /**
  831.  * Select a specific track.  For audio or video, this disables adaptation.
  832.  * Note that AdaptationEvents are not fired for manual track selections.
  833.  *
  834.  * @param {shakaExtern.Track} track
  835.  * @param {boolean=} opt_clearBuffer
  836.  * @export
  837.  */
  838. shaka.Player.prototype.selectTrack = function(track, opt_clearBuffer) {
  839.   if (!this.streamingEngine_)
  840.     return;
  842.   var period = this.streamingEngine_.getCurrentPeriod();
  843.   var data = shaka.util.StreamUtils.findStreamForTrack(period, track);
  844.   if (!data) {
  845.     shaka.log.error('Unable to find the track with id "' + track.id +
  846.                     '"; did we change Periods?');
  847.     return;
  848.   }
  849.   var stream = data.stream;
  851.   // Double check that the track is allowed to be played.
  852.   if (!stream.allowedByApplication || !stream.allowedByKeySystem) {
  853.     shaka.log.error('Unable to switch to track with id "' + track.id +
  854.                     '" because it is restricted.');
  855.     return;
  856.   }
  858.   // Add an entry to the history.
  859.   this.switchHistory_.push({
  860.     timestamp: Date.now() / 1000,
  861.     id: stream.id,
  862.     type: track.type,
  863.     fromAdaptation: false
  864.   });
  866.   if (track.type != 'text') {
  867.     // Disable ABR for anything other than text track changes.
  868.     var config = /** @type {shakaExtern.PlayerConfiguration} */ (
  869.         {abr: {enabled: false}});
  870.     this.configure(config);
  871.   }
  873.   var streamsToSwitch = {};
  874.   streamsToSwitch[track.type] = stream;
  875.   this.deferredSwitch_(streamsToSwitch, opt_clearBuffer);
  876. };
  879. /**
  880.  * @return {boolean} True if the current text track is visible.
  881.  * @export
  882.  */
  883. shaka.Player.prototype.isTextTrackVisible = function() {
  884.   return this.textTrack_.mode == 'showing';
  885. };
  888. /**
  889.  * Set the visibility of the current text track, if any.
  890.  *
  891.  * @param {boolean} on
  892.  * @export
  893.  */
  894. shaka.Player.prototype.setTextTrackVisibility = function(on) {
  895.   this.textTrack_.mode = on ? 'showing' : 'hidden';
  896.   this.onTextTrackVisibility_();
  897. };
  900. /**
  901.  * Return playback and adaptation stats.
  902.  *
  903.  * @return {shakaExtern.Stats}
  904.  * @export
  905.  */
  906. shaka.Player.prototype.getStats = function() {
  907.   this.updateStats_();
  909.   var video = {};
  910.   var audio = {};
  911.   var videoInfo = this.video_ && this.video_.getVideoPlaybackQuality ?
  912.       this.video_.getVideoPlaybackQuality() :
  913.       {};
  914.   if (this.streamingEngine_) {
  915.     var activeStreams = this.streamingEngine_.getActiveStreams();
  916.     video = activeStreams['video'] || {};
  917.     audio = activeStreams['audio'] || {};
  918.   }
  920.   return {
  921.     width: video.width || 0,
  922.     height: video.height || 0,
  923.     streamBandwidth: (video.bandwidth + audio.bandwidth) || 0,
  925.     decodedFrames: Number(videoInfo.totalVideoFrames),
  926.     droppedFrames: Number(videoInfo.droppedVideoFrames),
  927.     estimatedBandwidth: this.config_.abr.manager.getBandwidthEstimate(),
  928.     playTime: this.playTime_,
  929.     bufferingTime: this.bufferingTime_,
  931.     switchHistory: this.switchHistory_.slice(0)
  932.   };
  933. };
  936. /**
  937.  * Adds the given text track to the current Period.  Load() must resolve before
  938.  * calling.  The current Period or the presentation must have a duration.  This
  939.  * returns a Promise that will resolve when the track can be switched to and
  940.  * will resolve with the track that was created.
  941.  *
  942.  * @param {string} uri
  943.  * @param {string} language
  944.  * @param {string} kind
  945.  * @param {string} mime
  946.  * @param {string=} opt_codec
  947.  * @return {!Promise.<shakaExtern.Track>}
  948.  * @export
  949.  */
  950. shaka.Player.prototype.addTextTrack = function(
  951.     uri, language, kind, mime, opt_codec) {
  952.   if (!this.streamingEngine_) {
  953.     shaka.log.error(
  954.         'Must call load() and wait for it to resolve before adding text ' +
  955.         'tracks.');
  956.     return Promise.reject();
  957.   }
  959.   // Get the Period duration.
  960.   var period = this.streamingEngine_.getCurrentPeriod();
  961.   /** @type {number} */
  962.   var periodDuration;
  963.   for (var i = 0; i < this.manifest_.periods.length; i++) {
  964.     if (this.manifest_.periods[i] == period) {
  965.       if (i == this.manifest_.periods.length - 1) {
  966.         periodDuration = this.manifest_.presentationTimeline.getDuration() -
  967.             period.startTime;
  968.         if (periodDuration == Infinity) {
  969.           shaka.log.error(
  970.               'The current Period or the presentation must have a duration ' +
  971.               'to add external text tracks.');
  972.           return Promise.reject();
  973.         }
  974.       } else {
  975.         var nextPeriod = this.manifest_.periods[i + 1];
  976.         periodDuration = nextPeriod.startTime - period.startTime;
  977.       }
  978.       break;
  979.     }
  980.   }
  982.   /** @type {shakaExtern.Stream} */
  983.   var stream = {
  984.     id: this.nextExternalStreamId_++,
  985.     createSegmentIndex: Promise.resolve.bind(Promise),
  986.     findSegmentPosition: function(time) { return 1; },
  987.     getSegmentReference: function(ref) {
  988.       if (ref != 1) return null;
  989.       return new shaka.media.SegmentReference(
  990.           1, 0, periodDuration, function() { return [uri]; }, 0, null);
  991.     },
  992.     initSegmentReference: null,
  993.     presentationTimeOffset: 0,
  994.     mimeType: mime,
  995.     codecs: opt_codec || '',
  996.     bandwidth: 0,
  997.     kind: kind,
  998.     encrypted: false,
  999.     keyId: null,
  1000.     language: language,
  1001.     allowedByApplication: true,
  1002.     allowedByKeySystem: true
  1003.   };
  1004.   /** @type {shakaExtern.StreamSet} */
  1005.   var streamSet = {
  1006.     language: language,
  1007.     type: 'text',
  1008.     primary: false,
  1009.     drmInfos: [],
  1010.     streams: [stream]
  1011.   };
  1013.   // Add the stream to the loading list to ensure it isn't switched to while it
  1014.   // is initializing.
  1015.   this.loadingTextStreamIds_.push(stream.id);
  1016.   period.streamSets.push(streamSet);
  1018.   return this.streamingEngine_.notifyNewStream('text', stream).then(function() {
  1019.     if (this.destroyed_) return;
  1021.     // Remove the stream from the loading list.
  1022.     this.loadingTextStreamIds_.splice(
  1023.         this.loadingTextStreamIds_.indexOf(stream.id), 1);
  1025.     shaka.log.debug('Choosing new streams after adding a text stream');
  1026.     this.chooseStreamsAndSwitch_(period);
  1027.     this.onTracksChanged_();
  1029.     return {
  1030.       id: stream.id,
  1031.       active: false,
  1032.       type: 'text',
  1033.       bandwidth: 0,
  1034.       language: language,
  1035.       kind: kind,
  1036.       width: null,
  1037.       height: null
  1038.     };
  1039.   }.bind(this));
  1040. };
  1043. /**
  1044.  * Set the maximum resolution that the platform's hardware can handle.
  1045.  * This will be called automatically by shaka.cast.CastReceiver to enforce
  1046.  * limitations of the Chromecast hardware.
  1047.  *
  1048.  * @param {number} width
  1049.  * @param {number} height
  1050.  * @export
  1051.  */
  1052. shaka.Player.prototype.setMaxHardwareResolution = function(width, height) {
  1053.   this.maxHwRes_.width = width;
  1054.   this.maxHwRes_.height = height;
  1055. };
  1058. /**
  1059.  * Initialize the Player.
  1060.  * @private
  1061.  */
  1062. shaka.Player.prototype.initialize_ = function() {
  1063.   // Start the (potentially slow) process of opening MediaSource now.
  1064.   this.mediaSourceOpen_ = this.createMediaSource();
  1066.   // If the video element has TextTracks, disable them.  If we see one that
  1067.   // was created by a previous instance of Shaka Player, reuse it.
  1068.   for (var i = 0; i < this.video_.textTracks.length; ++i) {
  1069.     var track = this.video_.textTracks[i];
  1070.     track.mode = 'disabled';
  1072.     if (track.label == shaka.Player.TextTrackLabel_) {
  1073.       this.textTrack_ = track;
  1074.     }
  1075.   }
  1077.   if (!this.textTrack_) {
  1078.     // As far as I can tell, there is no observable difference between setting
  1079.     // kind to 'subtitles' or 'captions' when creating the TextTrack object.
  1080.     // The individual text tracks from the manifest will still have their own
  1081.     // kinds which can be displayed in the app's UI.
  1082.     this.textTrack_ = this.video_.addTextTrack(
  1083.         'subtitles', shaka.Player.TextTrackLabel_);
  1084.   }
  1085.   this.textTrack_.mode = 'hidden';
  1087.   // TODO: test that in all cases, the built-in CC controls in the video element
  1088.   // are toggling our TextTrack.
  1090.   // Listen for video errors.
  1091.   this.eventManager_.listen(this.video_, 'error',
  1092.       this.onVideoError_.bind(this));
  1093. };
  1096. /**
  1097.  * Destroy members responsible for streaming.
  1098.  *
  1099.  * @return {!Promise}
  1100.  * @private
  1101.  */
  1102. shaka.Player.prototype.destroyStreaming_ = function() {
  1103.   if (this.eventManager_) {
  1104.     this.eventManager_.unlisten(this.mediaSource_, 'sourceopen');
  1105.   }
  1107.   if (this.video_) {
  1108.     this.video_.removeAttribute('src');
  1109.     this.video_.load();
  1110.   }
  1112.   var p = Promise.all([
  1113.     this.config_ ? this.config_.abr.manager.stop() : null,
  1114.     this.drmEngine_ ? this.drmEngine_.destroy() : null,
  1115.     this.mediaSourceEngine_ ? this.mediaSourceEngine_.destroy() : null,
  1116.     this.playhead_ ? this.playhead_.destroy() : null,
  1117.     this.streamingEngine_ ? this.streamingEngine_.destroy() : null,
  1118.     this.parser_ ? this.parser_.stop() : null
  1119.   ]);
  1121.   this.drmEngine_ = null;
  1122.   this.mediaSourceEngine_ = null;
  1123.   this.playhead_ = null;
  1124.   this.streamingEngine_ = null;
  1125.   this.parser_ = null;
  1126.   this.manifest_ = null;
  1127.   this.manifestUri_ = null;
  1128.   this.mediaSourceOpen_ = null;
  1129.   this.mediaSource_ = null;
  1130.   this.deferredSwitches_ = {};
  1131.   this.switchHistory_ = [];
  1132.   this.playTime_ = 0;
  1133.   this.bufferingTime_ = 0;
  1135.   return p;
  1136. };
  1139. /**
  1140.  * Reset the streaming system.
  1141.  * @return {!Promise}
  1142.  * @private
  1143.  */
  1144. shaka.Player.prototype.resetStreaming_ = function() {
  1145.   if (!this.parser_) {
  1146.     // Nothing is playing, so this is effectively a no-op.
  1147.     return Promise.resolve();
  1148.   }
  1150.   // Destroy the streaming system before we recreate everything.
  1151.   return this.destroyStreaming_().then(function() {
  1152.     if (this.destroyed_) return;
  1154.     // Force an exit from the buffering state.
  1155.     this.onBuffering_(false);
  1157.     // Start the (potentially slow) process of opening MediaSource now.
  1158.     this.mediaSourceOpen_ = this.createMediaSource();
  1159.   }.bind(this));
  1160. };
  1163. /**
  1164.  * @const {string}
  1165.  * @private
  1166.  */
  1167. shaka.Player.TextTrackLabel_ = 'Shaka Player TextTrack';
  1170. /**
  1171.  * @return {!Object}
  1172.  * @private
  1173.  */
  1174. shaka.Player.prototype.configOverrides_ = function() {
  1175.   return {
  1176.     '.drm.servers': '',
  1177.     '.drm.clearKeys': '',
  1178.     '.drm.advanced': {
  1179.       distinctiveIdentifierRequired: false,
  1180.       persistentStateRequired: false,
  1181.       videoRobustness: '',
  1182.       audioRobustness: '',
  1183.       serverCertificate: null
  1184.     }
  1185.   };
  1186. };
  1189. /**
  1190.  * @return {shakaExtern.PlayerConfiguration}
  1191.  * @private
  1192.  */
  1193. shaka.Player.prototype.defaultConfig_ = function() {
  1194.   return {
  1195.     drm: {
  1196.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  1197.       // These will all be verified by special cases in mergeConfigObjects_():
  1198.       servers: {},    // key is arbitrary key system ID, value must be string
  1199.       clearKeys: {},  // key is arbitrary key system ID, value must be string
  1200.       advanced: {}    // key is arbitrary key system ID, value is a record type
  1201.     },
  1202.     manifest: {
  1203.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  1204.       dash: {
  1205.         customScheme: function(node) {
  1206.           // Reference node to keep closure from removing it.
  1207.           // If the argument is removed, it breaks our function length check
  1208.           // in mergeConfigObjects_().
  1209.           // TODO: Find a better solution if possible.
  1210.           // NOTE: Chrome App Content Security Policy prohibits usage of new
  1211.           // Function()
  1213.           if (node) return null;
  1214.         },
  1215.         clockSyncUri: ''
  1216.       }
  1217.     },
  1218.     streaming: {
  1219.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  1220.       rebufferingGoal: 2,
  1221.       bufferingGoal: 30,
  1222.       bufferBehind: 30,
  1223.       ignoreTextStreamFailures: false
  1224.     },
  1225.     abr: {
  1226.       manager: this.defaultAbrManager_,
  1227.       enabled: true,
  1228.       defaultBandwidthEstimate:
  1229.           shaka.abr.EwmaBandwidthEstimator.DEFAULT_ESTIMATE
  1230.     },
  1231.     preferredAudioLanguage: '',
  1232.     preferredTextLanguage: '',
  1233.     restrictions: {
  1234.       minWidth: 0,
  1235.       maxWidth: Infinity,
  1236.       minHeight: 0,
  1237.       maxHeight: Infinity,
  1238.       minPixels: 0,
  1239.       maxPixels: Infinity,
  1240.       minAudioBandwidth: 0,
  1241.       maxAudioBandwidth: Infinity,
  1242.       minVideoBandwidth: 0,
  1243.       maxVideoBandwidth: Infinity
  1244.     }
  1245.   };
  1246. };
  1249. /**
  1250.  * @param {shakaExtern.Period} period
  1251.  * @private
  1252.  */
  1253. shaka.Player.prototype.filterPeriod_ = function(period) {
  1254.   goog.asserts.assert(this.video_, 'Must not be destroyed');
  1256.   var activeStreams =
  1257.       this.streamingEngine_ ? this.streamingEngine_.getActiveStreams() : {};
  1258.   shaka.util.StreamUtils.filterPeriod(this.drmEngine_, activeStreams, period);
  1260.   // Check for playable streams before restrictions to give a different error
  1261.   // if we have restricted all the tracks rather than there being none.
  1262.   var hasPlayableStreamSets =
  1263.       period.streamSets.some(shaka.util.StreamUtils.hasPlayableStreams);
  1265.   var tracksChanged = shaka.util.StreamUtils.applyRestrictions(
  1266.       period, this.config_.restrictions, this.maxHwRes_);
  1267.   if (tracksChanged && !this.loadChain_)
  1268.     this.onTracksChanged_();
  1270.   var allStreamsRestricted =
  1271.       !period.streamSets.some(shaka.util.StreamUtils.hasPlayableStreams);
  1272.   if (!hasPlayableStreamSets) {
  1273.     this.onError_(new shaka.util.Error(
  1274.         shaka.util.Error.Category.MANIFEST,
  1275.         shaka.util.Error.Code.UNPLAYABLE_PERIOD));
  1276.   } else if (allStreamsRestricted) {
  1277.     this.onError_(new shaka.util.Error(
  1278.         shaka.util.Error.Category.MANIFEST,
  1279.         shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET));
  1280.   }
  1281. };
  1284. /**
  1285.  * Switches to the given streams, deferring switches if needed.
  1286.  * @param {!Object.<string, shakaExtern.Stream>} streamsByType
  1287.  * @param {boolean=} opt_clearBuffer
  1288.  * @private
  1289.  */
  1290. shaka.Player.prototype.deferredSwitch_ = function(
  1291.     streamsByType, opt_clearBuffer) {
  1292.   for (var type in streamsByType) {
  1293.     var stream = streamsByType[type];
  1294.     var clear = opt_clearBuffer || type == 'text';
  1295.     if (this.switchingPeriods_) {
  1296.       this.deferredSwitches_[type] = {stream: stream, clear: clear};
  1297.     } else {
  1298.       var opt_leaveInBuffer = clear ? 0 : undefined;
  1299.       this.streamingEngine_.switch(type, stream, opt_leaveInBuffer);
  1300.     }
  1301.   }
  1302. };
  1305. /** @private */
  1306. shaka.Player.prototype.updateStats_ = function() {
  1307.   // Only count while we're loaded.
  1308.   if (!this.manifest_)
  1309.     return;
  1311.   var now = Date.now() / 1000;
  1312.   if (this.buffering_)
  1313.     this.bufferingTime_ += (now - this.lastStatUpdateTimestamp_);
  1314.   else
  1315.     this.playTime_ += (now - this.lastStatUpdateTimestamp_);
  1317.   this.lastStatUpdateTimestamp_ = now;
  1318. };
  1321. /**
  1322.  * Callback from NetworkingEngine.
  1323.  *
  1324.  * @param {number} startTimeMs
  1325.  * @param {number} endTimeMs
  1326.  * @param {number} numBytes
  1327.  * @private
  1328.  */
  1329. shaka.Player.prototype.onSegmentDownloaded_ = function(
  1330.     startTimeMs, endTimeMs, numBytes) {
  1331.   this.config_.abr.manager.segmentDownloaded(startTimeMs, endTimeMs, numBytes);
  1332. };
  1335. /**
  1336.  * Callback from Playhead.
  1337.  *
  1338.  * @param {boolean} buffering
  1339.  * @private
  1340.  */
  1341. shaka.Player.prototype.onBuffering_ = function(buffering) {
  1342.   // Before setting |buffering_|, update the time spent in the previous state.
  1343.   this.updateStats_();
  1344.   this.buffering_ = buffering;
  1346.   var event = new shaka.util.FakeEvent('buffering', { 'buffering': buffering });
  1347.   this.dispatchEvent(event);
  1348. };
  1351. /**
  1352.  * Callback from Playhead.
  1353.  *
  1354.  * @private
  1355.  */
  1356. shaka.Player.prototype.onSeek_ = function() {
  1357.   if (this.streamingEngine_) {
  1358.     this.streamingEngine_.seeked();
  1359.   }
  1360. };
  1363. /**
  1364.  * Chooses streams from the given Period.
  1365.  *
  1366.  * @param {!shakaExtern.Period} period
  1367.  * @param {!Object.<string, shakaExtern.StreamSet>} streamSetsByType
  1368.  * @param {boolean=} opt_chooseAll If true, choose streams from all stream sets.
  1369.  * @return {!Object.<string, !shakaExtern.Stream>} A map of stream types to
  1370.  *   chosen streams.
  1371.  * @private
  1372.  */
  1373. shaka.Player.prototype.chooseStreams_ =
  1374.     function(period, streamSetsByType, opt_chooseAll) {
  1375.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  1377.   var hasPlayableStreams = shaka.util.StreamUtils.hasPlayableStreams;
  1379.   // If there are no unrestricted streams, issue an error.
  1380.   var manifestIsPlayable =
  1381.       shaka.util.MapUtils.values(streamSetsByType).some(hasPlayableStreams);
  1382.   if (!manifestIsPlayable) {
  1383.     this.onError_(new shaka.util.Error(
  1384.         shaka.util.Error.Category.MANIFEST,
  1385.         shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET));
  1386.     return {};
  1387.   }
  1389.   // Which StreamSets need to have their chosen stream updated.
  1390.   var needsUpdate = {};
  1392.   if (opt_chooseAll) {
  1393.     // Choose new streams for all types.
  1394.     needsUpdate = streamSetsByType;
  1395.   } else {
  1396.     // Check if any of the active streams is no longer available
  1397.     // or is using the wrong language.
  1398.     var activeStreams = this.streamingEngine_.getActiveStreams();
  1399.     for (var type in activeStreams) {
  1400.       var stream = activeStreams[type];
  1401.       if (!stream.allowedByApplication ||
  1402.           !stream.allowedByKeySystem ||
  1403.           streamSetsByType[type].language != stream.language) {
  1404.         needsUpdate[type] = streamSetsByType[type];
  1405.       }
  1406.     }
  1407.   }
  1409.   if (!shaka.util.MapUtils.empty(needsUpdate)) {
  1410.     shaka.log.debug('Choosing new streams for', Object.keys(needsUpdate));
  1411.     var chosen = this.config_.abr.manager.chooseStreams(needsUpdate);
  1412.     if (!shaka.util.MapUtils.every(needsUpdate,
  1413.         function(type, set) { return !!chosen[type]; })) {
  1414.       // Not every type was chosen!  This should only happen when output
  1415.       // restrictions prevent playback of a certain type and there are no
  1416.       // usable streams for that type.
  1417.       this.onError_(new shaka.util.Error(
  1418.           shaka.util.Error.Category.MANIFEST,
  1419.           shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET));
  1420.       return {};
  1421.     }
  1422.     return chosen;
  1423.   } else {
  1424.     shaka.log.debug('No new streams need to be chosen.');
  1425.     return {};
  1426.   }
  1427. };
  1430. /**
  1431.  * Chooses streams from the given Period and switches to them.
  1432.  *
  1433.  * @param {!shakaExtern.Period} period
  1434.  * @private
  1435.  */
  1436. shaka.Player.prototype.chooseStreamsAndSwitch_ = function(period) {
  1437.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  1438.   var languageMatches = { 'audio': false, 'text': false };
  1439.   var streamSetsByType = shaka.util.StreamUtils.chooseStreamSets(
  1440.       period, this.config_, languageMatches);
  1441.   var chosen = this.chooseStreams_(period, streamSetsByType);
  1443.   for (var type in chosen) {
  1444.     var stream = chosen[type];
  1445.     this.switchHistory_.push({
  1446.       timestamp: Date.now() / 1000,
  1447.       id: stream.id,
  1448.       type: type,
  1449.       fromAdaptation: true
  1450.     });
  1451.   }
  1453.   // TODO: are these cases where we should avoid clearBuffer at this point?
  1454.   this.deferredSwitch_(chosen, /* clearBuffer */ true);
  1456.   // Send an adaptation event so that the UI can show the new language/tracks.
  1457.   this.onAdaptation_();
  1459.   if (streamSetsByType['text']) {
  1460.     // If audio and text tracks have different languages, and the text track
  1461.     // matches the user's preference, then show the captions.
  1462.     if (streamSetsByType['audio'] &&
  1463.         languageMatches['text'] &&
  1464.         streamSetsByType['text'].language !=
  1465.             streamSetsByType['audio'].language) {
  1466.       this.textTrack_.mode = 'showing';
  1467.       this.onTextTrackVisibility_();
  1468.     }
  1469.   }
  1470. };
  1473. /**
  1474.  * Callback from StreamingEngine.
  1475.  *
  1476.  * @param {!shakaExtern.Period} period
  1477.  * @return {!Object.<string, !shakaExtern.Stream>} A map of stream types to
  1478.  *   chosen streams.
  1479.  * @private
  1480.  */
  1481. shaka.Player.prototype.onChooseStreams_ = function(period) {
  1482.   shaka.log.debug('onChooseStreams_', period);
  1483.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  1485.   // We are switching Periods, so the AbrManager will be disabled.  But if we
  1486.   // want to abr.enabled, we do not want to call AbrManager.enable before
  1487.   // canSwitch_ is called.
  1488.   this.switchingPeriods_ = true;
  1489.   this.config_.abr.manager.disable();
  1491.   shaka.log.debug('Choosing new streams after period changed');
  1492.   var streamSetsByType = shaka.util.StreamUtils.chooseStreamSets(
  1493.       period, this.config_);
  1494.   shaka.log.v2('onChooseStreams_, streamSetsByType=', streamSetsByType);
  1495.   var chosen = this.chooseStreams_(
  1496.       period, streamSetsByType, /* opt_chooseAll */ true);
  1497.   shaka.log.v2('onChooseStreams_, chosen=', chosen);
  1499.   // Override the chosen streams with the ones picked in selectTrack.
  1500.   // NOTE: The apparent race between selectTrack and period transition is
  1501.   // handled by StreamingEngine, which will re-request tracks for the
  1502.   // transition if any of these deferred selections are from the wrong period.
  1503.   for (var type in this.deferredSwitches_) {
  1504.     // We are choosing initial tracks, so no segments from this Period have
  1505.     // been downloaded yet.
  1506.     chosen[type] = this.deferredSwitches_[type].stream;
  1507.   }
  1508.   this.deferredSwitches_ = {};
  1510.   for (var type in chosen) {
  1511.     var stream = chosen[type];
  1512.     this.switchHistory_.push({
  1513.       timestamp: Date.now() / 1000,
  1514.       id: stream.id,
  1515.       type: type,
  1516.       fromAdaptation: true
  1517.     });
  1518.   }
  1520.   // If we are presently loading, we aren't done filtering streams just yet.
  1521.   // Wait to send a 'trackschanged' event.
  1522.   if (!this.loadChain_) {
  1523.     this.onTracksChanged_();
  1524.   }
  1526.   return chosen;
  1527. };
  1530. /**
  1531.  * Callback from StreamingEngine.
  1532.  *
  1533.  * @private
  1534.  */
  1535. shaka.Player.prototype.canSwitch_ = function() {
  1536.   shaka.log.debug('canSwitch_');
  1537.   this.switchingPeriods_ = false;
  1538.   if (this.config_.abr.enabled)
  1539.     this.config_.abr.manager.enable();
  1541.   // If we still have deferred switches, switch now.
  1542.   for (var type in this.deferredSwitches_) {
  1543.     var info = this.deferredSwitches_[type];
  1544.     var opt_leaveInBuffer = info.clear ? 0 : undefined;
  1545.     this.streamingEngine_.switch(type, info.stream, opt_leaveInBuffer);
  1546.   }
  1547.   this.deferredSwitches_ = {};
  1548. };
  1551. /**
  1552.  * Callback from AbrManager.
  1553.  *
  1554.  * @param {!Object.<string, !shakaExtern.Stream>} streamsByType
  1555.  * @param {number=} opt_leaveInBuffer
  1556.  * @private
  1557.  */
  1558. shaka.Player.prototype.switch_ = function(streamsByType, opt_leaveInBuffer) {
  1559.   shaka.log.debug('switch_');
  1560.   goog.asserts.assert(this.config_.abr.enabled,
  1561.       'AbrManager should not call switch while disabled!');
  1562.   goog.asserts.assert(!this.switchingPeriods_,
  1563.       'AbrManager should not call switch while transitioning between Periods!');
  1565.   // We have adapted to a new stream, record it in the history.  Only add if
  1566.   // we are actually switching the stream.
  1567.   var oldActive = this.streamingEngine_.getActiveStreams();
  1568.   for (var type in streamsByType) {
  1569.     var stream = streamsByType[type];
  1570.     if (oldActive[type] != stream) {
  1571.       this.switchHistory_.push({
  1572.         timestamp: Date.now() / 1000,
  1573.         id: stream.id,
  1574.         type: type,
  1575.         fromAdaptation: true
  1576.       });
  1577.     } else {
  1578.       // If it's the same, remove it from the map.
  1579.       // This allows us to avoid onAdaptation_() when nothing has changed.
  1580.       delete streamsByType[type];
  1581.     }
  1582.   }
  1584.   if (shaka.util.MapUtils.empty(streamsByType)) {
  1585.     // There's nothing to change.
  1586.     return;
  1587.   }
  1589.   if (!this.streamingEngine_) {
  1590.     // There's no way to change it.
  1591.     return;
  1592.   }
  1594.   for (var type in streamsByType) {
  1595.     this.streamingEngine_.switch(type, streamsByType[type],
  1596.         // Only apply opt_leaveInBuffer to video streams.
  1597.         type == 'video' ? opt_leaveInBuffer : undefined);
  1598.   }
  1599.   this.onAdaptation_();
  1600. };
  1603. /**
  1604.  * Dispatches a 'adaptation' event.
  1605.  * @private
  1606.  */
  1607. shaka.Player.prototype.onAdaptation_ = function() {
  1608.   // In the next frame, dispatch a 'adaptation' event.
  1609.   // This gives StreamingEngine time to absorb the changes before the user
  1610.   // tries to query them.
  1611.   Promise.resolve().then(function() {
  1612.     if (this.destroyed_) return;
  1613.     var event = new shaka.util.FakeEvent('adaptation');
  1614.     this.dispatchEvent(event);
  1615.   }.bind(this));
  1616. };
  1619. /**
  1620.  * Dispatches a 'trackschanged' event.
  1621.  * @private
  1622.  */
  1623. shaka.Player.prototype.onTracksChanged_ = function() {
  1624.   // In the next frame, dispatch a 'trackschanged' event.
  1625.   // This gives StreamingEngine time to absorb the changes before the user
  1626.   // tries to query them.
  1627.   Promise.resolve().then(function() {
  1628.     if (this.destroyed_) return;
  1629.     var event = new shaka.util.FakeEvent('trackschanged');
  1630.     this.dispatchEvent(event);
  1631.   }.bind(this));
  1632. };
  1635. /** @private */
  1636. shaka.Player.prototype.onTextTrackVisibility_ = function() {
  1637.   var event = new shaka.util.FakeEvent('texttrackvisibility');
  1638.   this.dispatchEvent(event);
  1639. };
  1642. /**
  1643.  * @param {!shaka.util.Error} error
  1644.  * @private
  1645.  */
  1646. shaka.Player.prototype.onError_ = function(error) {
  1647.   goog.asserts.assert(error instanceof shaka.util.Error, 'Wrong error type!');
  1649.   var event = new shaka.util.FakeEvent('error', { 'detail': error });
  1650.   this.dispatchEvent(event);
  1651. };
  1654. /**
  1655.  * @param {!shaka.util.FakeEvent} event
  1656.  * @private
  1657.  */
  1658. shaka.Player.prototype.onEvent_ = function(event) {
  1659.   this.dispatchEvent(event);
  1660. };
  1663. /**
  1664.  * @param {!Event} event
  1665.  * @private
  1666.  */
  1667. shaka.Player.prototype.onVideoError_ = function(event) {
  1668.   if (!this.video_.error) return;
  1670.   var code = this.video_.error.code;
  1671.   if (code == 1 /* MEDIA_ERR_ABORTED */) {
  1672.     // Ignore this error code, which should only occur when navigating away or
  1673.     // deliberately stopping playback of HTTP content.
  1674.     return;
  1675.   }
  1677.   // Extra error information from MS Edge and IE11:
  1678.   var extended = this.video_.error.msExtendedCode;
  1679.   if (extended) {
  1680.     // Convert to unsigned:
  1681.     if (extended < 0) {
  1682.       extended += Math.pow(2, 32);
  1683.     }
  1684.     // Format as hex:
  1685.     extended = extended.toString(16);
  1686.   }
  1688.   this.onError_(new shaka.util.Error(
  1689.       shaka.util.Error.Category.MEDIA,
  1690.       shaka.util.Error.Code.VIDEO_ERROR,
  1691.       code, extended));
  1692. };
  1695. /**
  1696.  * @param {!Object.<string, string>} keyStatusMap A map of hex key IDs to
  1697.  *   statuses.
  1698.  * @private
  1699.  */
  1700. shaka.Player.prototype.onKeyStatus_ = function(keyStatusMap) {
  1701.   goog.asserts.assert(this.streamingEngine_, 'Should have been initialized.');
  1702.   // 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
  1703.   // of the usable keys.
  1704.   // 'expired' and 'internal-error' are error statuses which are being handled
  1705.   // separately in DrmEngine.
  1706.   var restrictedStatus = 'output-restricted';
  1708.   var period = this.streamingEngine_.getCurrentPeriod();
  1709.   var tracksChanged = false;
  1711.   period.streamSets.forEach(function(streamSet) {
  1712.     streamSet.streams.forEach(function(stream) {
  1713.       var originalAllowed = stream.allowedByKeySystem;
  1715.       // Only update the status if it is in the map.
  1716.       if (stream.keyId && stream.keyId in keyStatusMap) {
  1717.         var keyStatus = keyStatusMap[stream.keyId];
  1718.         stream.allowedByKeySystem = keyStatus != restrictedStatus;
  1719.       }
  1721.       if (originalAllowed != stream.allowedByKeySystem) {
  1722.         tracksChanged = true;
  1723.       }
  1724.     });
  1725.   });
  1727.   shaka.log.debug('Choosing new streams after key status changed');
  1728.   this.chooseStreamsAndSwitch_(period);
  1730.   if (tracksChanged)
  1731.     this.onTracksChanged_();
  1732. };