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.PlayheadObserver');
  28. goog.require('shaka.media.SegmentReference');
  29. goog.require('shaka.media.StreamingEngine');
  30. goog.require('shaka.net.NetworkingEngine');
  31. goog.require('shaka.text.SimpleTextDisplayer');
  32. goog.require('shaka.util.ArrayUtils');
  33. goog.require('shaka.util.ConfigUtils');
  34. goog.require('shaka.util.Error');
  35. goog.require('shaka.util.EventManager');
  36. goog.require('shaka.util.FakeEvent');
  37. goog.require('shaka.util.FakeEventTarget');
  38. goog.require('shaka.util.Functional');
  39. goog.require('shaka.util.IDestroyable');
  40. goog.require('shaka.util.ManifestParserUtils');
  41. goog.require('shaka.util.MapUtils');
  42. goog.require('shaka.util.PublicPromise');
  43. goog.require('shaka.util.StreamUtils');
  47. /**
  48.  * Construct a Player.
  49.  *
  50.  * @param {HTMLMediaElement=} mediaElem If provided, this is equivalent to
  51.  *   calling attach(mediaElem, true) immediately after construction.
  52.  * @param {function(shaka.Player)=} opt_dependencyInjector Optional callback
  53.  *   which is called to inject mocks into the Player.  Used for testing.
  54.  *
  55.  * @constructor
  56.  * @struct
  57.  * @implements {shaka.util.IDestroyable}
  58.  * @extends {shaka.util.FakeEventTarget}
  59.  * @export
  60.  */
  61. shaka.Player = function(mediaElem, opt_dependencyInjector) {
  62.   shaka.util.FakeEventTarget.call(this);
  64.   /** @private {boolean} */
  65.   this.destroyed_ = false;
  67.   /** @private {HTMLMediaElement} */
  68.   this.video_ = null;
  70.   /**
  71.    * Only holds the visibility setting until a textDisplayer_ is created.
  72.    * @private {boolean}
  73.    */
  74.   this.textVisibility_ = false;
  76.   /** @private {shakaExtern.TextDisplayer} */
  77.   this.textDisplayer_ = null;
  79.   /** @private {shaka.util.EventManager} */
  80.   this.eventManager_ = new shaka.util.EventManager();
  82.   /** @private {shaka.net.NetworkingEngine} */
  83.   this.networkingEngine_ = null;
  85.   /** @private {shaka.media.DrmEngine} */
  86.   this.drmEngine_ = null;
  88.   /** @private {shaka.media.MediaSourceEngine} */
  89.   this.mediaSourceEngine_ = null;
  91.   /** @private {shaka.media.Playhead} */
  92.   this.playhead_ = null;
  94.   /** @private {shaka.media.PlayheadObserver} */
  95.   this.playheadObserver_ = null;
  97.   /** @private {shaka.media.StreamingEngine} */
  98.   this.streamingEngine_ = null;
  100.   /** @private {shakaExtern.ManifestParser} */
  101.   this.parser_ = null;
  103.   /** @private {?shakaExtern.Manifest} */
  104.   this.manifest_ = null;
  106.   /** @private {?string} */
  107.   this.manifestUri_ = null;
  109.   /** @private {shakaExtern.AbrManager} */
  110.   this.abrManager_ = null;
  112.   /**
  113.    * The factory that was used to create the abrManager_ instance.
  114.    * @private {?shakaExtern.AbrManager.Factory}
  115.    */
  116.   this.abrManagerFactory_ = null;
  118.   /**
  119.    * Contains an ID for use with creating streams.  The manifest parser should
  120.    * start with small IDs, so this starts with a large one.
  121.    * @private {number}
  122.    */
  123.   this.nextExternalStreamId_ = 1e9;
  125.   /** @private {!Array.<number>} */
  126.   this.loadingTextStreamIds_ = [];
  128.   /** @private {boolean} */
  129.   this.buffering_ = false;
  131.   /** @private {boolean} */
  132.   this.switchingPeriods_ = true;
  134.   /** @private {?function()} */
  135.   this.onCancelLoad_ = null;
  137.   /** @private {Promise} */
  138.   this.unloadChain_ = null;
  140.   /** @private {?shakaExtern.Variant} */
  141.   this.deferredVariant_ = null;
  143.   /** @private {boolean} */
  144.   this.deferredVariantClearBuffer_ = false;
  146.   /** @private {?shakaExtern.Stream} */
  147.   this.deferredTextStream_ = null;
  149.   /** @private {!Array.<shakaExtern.TimelineRegionInfo>} */
  150.   this.pendingTimelineRegions_ = [];
  152.   /**
  153.    * A map of Period number to a map of content type to stream id.
  154.    * @private {!Object.<number, !Object.<string, number>>}
  155.    */
  156.   this.activeStreamsByPeriod_ = {};
  158.   /** @private {?shakaExtern.PlayerConfiguration} */
  159.   this.config_ = this.defaultConfig_();
  161.   /** @private {{width: number, height: number}} */
  162.   this.maxHwRes_ = {width: Infinity, height: Infinity};
  164.   /** @private {shakaExtern.Stats} */
  165.   this.stats_ = this.getCleanStats_();
  167.   /** @private {number} */
  168.   this.lastTimeStatsUpdateTimestamp_ = 0;
  170.   /** @private {string} */
  171.   this.currentAudioLanguage_ = this.config_.preferredAudioLanguage;
  173.   /** @private {string} */
  174.   this.currentTextLanguage_ = this.config_.preferredTextLanguage;
  176.   /** @private {string} */
  177.   this.currentVariantRole_ = this.config_.preferredVariantRole;
  179.   /** @private {string} */
  180.   this.currentTextRole_ = this.config_.preferredTextRole;
  182.   /** @private {number} */
  183.   this.currentAudioChannelCount_ = this.config_.preferredAudioChannelCount;
  185.   if (opt_dependencyInjector) {
  186.     opt_dependencyInjector(this);
  187.   }
  189.   this.networkingEngine_ = this.createNetworkingEngine();
  191.   if (mediaElem) {
  192.     this.attach(mediaElem, true /* initializeMediaSource */);
  193.   }
  195.   // If the browser comes back online after being offline, then try to play
  196.   // again.
  197.   this.eventManager_.listen(window, 'online', () => {
  198.     this.retryStreaming();
  199.   });
  200. };
  201. goog.inherits(shaka.Player, shaka.util.FakeEventTarget);
  204. /**
  205.  * @return {!Promise}
  206.  * @private
  207.  */
  208. shaka.Player.prototype.cancelLoad_ = function() {
  209.   if (!this.onCancelLoad_) {
  210.     return Promise.resolve();
  211.   }
  213.   let stopParser = Promise.resolve();
  214.   if (this.parser_) {
  215.     // Stop the parser manually, to ensure that any network calls it may be
  216.     // making are stopped in a timely fashion.
  217.     // This happens in parallel with cancelling the load chain.
  218.     // Otherwise, destroying will wait for any failing network calls to run
  219.     // out of retries.
  220.     stopParser = this.parser_.stop();
  221.     this.parser_ = null;
  222.   }
  223.   return Promise.all([stopParser, this.onCancelLoad_()]);
  224. };
  227. /**
  228.  * After destruction, a Player object cannot be used again.
  229.  *
  230.  * @override
  231.  * @export
  232.  */
  233. shaka.Player.prototype.destroy = async function() {
  234.   // First, detach from the media element.  This implies unloading content
  235.   // and canceling pending loads.
  236.   await this.detach();
  237.   // Then, destroy other components and clear fields.
  239.   this.destroyed_ = true;
  241.   let p = Promise.all([
  242.     this.eventManager_ ? this.eventManager_.destroy() : null,
  243.     this.networkingEngine_ ? this.networkingEngine_.destroy() : null
  244.   ]);
  246.   this.textVisibility_ = false;
  247.   this.eventManager_ = null;
  248.   this.abrManager_ = null;
  249.   this.abrManagerFactory_ = null;
  250.   this.networkingEngine_ = null;
  251.   this.config_ = null;
  252.   await p;
  253. };
  256. /**
  257.  * @define {string} A version number taken from git at compile time.
  258.  * @export
  259.  */
  260. shaka.Player.version = 'v2.4.7-uncompiled';
  263. /**
  264.  * @event shaka.Player.ErrorEvent
  265.  * @description Fired when a playback error occurs.
  266.  * @property {string} type
  267.  *   'error'
  268.  * @property {!shaka.util.Error} detail
  269.  *   An object which contains details on the error.  The error's 'category' and
  270.  *   'code' properties will identify the specific error that occurred.  In an
  271.  *   uncompiled build, you can also use the 'message' and 'stack' properties
  272.  *   to debug.
  273.  * @exportDoc
  274.  */
  277. /**
  278.  * @event shaka.Player.EmsgEvent
  279.  * @description Fired when a non-typical emsg is found in a segment.
  280.  * @property {string} type
  281.  *   'emsg'
  282.  * @property {shakaExtern.EmsgInfo} detail
  283.  *   An object which contains the content of the emsg box.
  284.  * @exportDoc
  285.  */
  288. /**
  289.  * @event shaka.Player.DrmSessionUpdateEvent
  290.  * @description Fired when the CDM has accepted the license response.
  291.  * @property {string} type
  292.  *   'drmsessionupdate'
  293.  * @exportDoc
  294.  */
  297. /**
  298.  * @event shaka.Player.TimelineRegionAddedEvent
  299.  * @description Fired when a media timeline region is added.
  300.  * @property {string} type
  301.  *   'timelineregionadded'
  302.  * @property {shakaExtern.TimelineRegionInfo} detail
  303.  *   An object which contains a description of the region.
  304.  * @exportDoc
  305.  */
  308. /**
  309.  * @event shaka.Player.TimelineRegionEnterEvent
  310.  * @description Fired when the playhead enters a timeline region.
  311.  * @property {string} type
  312.  *   'timelineregionenter'
  313.  * @property {shakaExtern.TimelineRegionInfo} detail
  314.  *   An object which contains a description of the region.
  315.  * @exportDoc
  316.  */
  319. /**
  320.  * @event shaka.Player.TimelineRegionExitEvent
  321.  * @description Fired when the playhead exits a timeline region.
  322.  * @property {string} type
  323.  *   'timelineregionexit'
  324.  * @property {shakaExtern.TimelineRegionInfo} detail
  325.  *   An object which contains a description of the region.
  326.  * @exportDoc
  327.  */
  330. /**
  331.  * @event shaka.Player.BufferingEvent
  332.  * @description Fired when the player's buffering state changes.
  333.  * @property {string} type
  334.  *   'buffering'
  335.  * @property {boolean} buffering
  336.  *   True when the Player enters the buffering state.
  337.  *   False when the Player leaves the buffering state.
  338.  * @exportDoc
  339.  */
  342. /**
  343.  * @event shaka.Player.LoadingEvent
  344.  * @description Fired when the player begins loading.
  345.  *   Used by the Cast receiver to determine idle state.
  346.  * @property {string} type
  347.  *   'loading'
  348.  * @exportDoc
  349.  */
  352. /**
  353.  * @event shaka.Player.UnloadingEvent
  354.  * @description Fired when the player unloads or fails to load.
  355.  *   Used by the Cast receiver to determine idle state.
  356.  * @property {string} type
  357.  *   'unloading'
  358.  * @exportDoc
  359.  */
  362. /**
  363.  * @event shaka.Player.TextTrackVisibilityEvent
  364.  * @description Fired when text track visibility changes.
  365.  * @property {string} type
  366.  *   'texttrackvisibility'
  367.  * @exportDoc
  368.  */
  371. /**
  372.  * @event shaka.Player.TracksChangedEvent
  373.  * @description Fired when the list of tracks changes.  For example, this will
  374.  *   happen when changing periods or when track restrictions change.
  375.  * @property {string} type
  376.  *   'trackschanged'
  377.  * @exportDoc
  378.  */
  381. /**
  382.  * @event shaka.Player.AdaptationEvent
  383.  * @description Fired when an automatic adaptation causes the active tracks
  384.  *   to change.  Does not fire when the application calls selectVariantTrack()
  385.  *   selectTextTrack(), selectAudioLanguage() or selectTextLanguage().
  386.  * @property {string} type
  387.  *   'adaptation'
  388.  * @exportDoc
  389.  */
  392. /**
  393.  * @event shaka.Player.ExpirationUpdatedEvent
  394.  * @description Fired when there is a change in the expiration times of an
  395.  *   EME session.
  396.  * @property {string} type
  397.  *   'expirationupdated'
  398.  * @exportDoc
  399.  */
  402. /**
  403.  * @event shaka.Player.LargeGapEvent
  404.  * @description Fired when the playhead enters a large gap.  If
  405.  *   |config.streaming.jumpLargeGaps| is set, the default action of this event
  406.  *   is to jump the gap; this can be prevented by calling preventDefault() on
  407.  *   the event object.
  408.  * @property {string} type
  409.  *   'largegap'
  410.  * @property {number} currentTime
  411.  *   The current time of the playhead.
  412.  * @property {number} gapSize
  413.  *   The size of the gap, in seconds.
  414.  * @exportDoc
  415.  */
  418. /**
  419.  * @event shaka.Player.StreamingEvent
  420.  * @description Fired after the manifest has been parsed and track information
  421.  *   is available, but before streams have been chosen and before any segments
  422.  *   have been fetched.  You may use this event to configure the player based on
  423.  *   information found in the manifest.
  424.  * @property {string} type
  425.  *   'streaming'
  426.  * @exportDoc
  427.  */
  430. /** @private {!Object.<string, function():*>} */
  431. shaka.Player.supportPlugins_ = {};
  434. /**
  435.  * Registers a plugin callback that will be called with support().  The
  436.  * callback will return the value that will be stored in the return value from
  437.  * support().
  438.  *
  439.  * @param {string} name
  440.  * @param {function():*} callback
  441.  * @export
  442.  */
  443. shaka.Player.registerSupportPlugin = function(name, callback) {
  444.   shaka.Player.supportPlugins_[name] = callback;
  445. };
  448. /**
  449.  * Return whether the browser provides basic support.  If this returns false,
  450.  * Shaka Player cannot be used at all.  In this case, do not construct a Player
  451.  * instance and do not use the library.
  452.  *
  453.  * @return {boolean}
  454.  * @export
  455.  */
  456. shaka.Player.isBrowserSupported = function() {
  457.   // Basic features needed for the library to be usable.
  458.   let basic = !!window.Promise && !!window.Uint8Array &&
  459.               !!Array.prototype.forEach;
  461.   return basic &&
  462.       shaka.media.MediaSourceEngine.isBrowserSupported() &&
  463.       shaka.media.DrmEngine.isBrowserSupported();
  464. };
  467. /**
  468.  * Probes the browser to determine what features are supported.  This makes a
  469.  * number of requests to EME/MSE/etc which may result in user prompts.  This
  470.  * should only be used for diagnostics.
  471.  *
  472.  * NOTE: This may show a request to the user for permission.
  473.  *
  474.  * @see https://goo.gl/ovYLvl
  475.  * @return {!Promise.<shakaExtern.SupportType>}
  476.  * @export
  477.  */
  478. shaka.Player.probeSupport = function() {
  479.   goog.asserts.assert(shaka.Player.isBrowserSupported(),
  480.                       'Must have basic support');
  481.   return shaka.media.DrmEngine.probeSupport().then(function(drm) {
  482.     let manifest = shaka.media.ManifestParser.probeSupport();
  483.     let media = shaka.media.MediaSourceEngine.probeSupport();
  484.     let ret = {
  485.       manifest: manifest,
  486.       media: media,
  487.       drm: drm
  488.     };
  490.     let plugins = shaka.Player.supportPlugins_;
  491.     for (let name in plugins) {
  492.       ret[name] = plugins[name]();
  493.     }
  495.     return ret;
  496.   });
  497. };
  500. /**
  501.  * Attach the Player to a media element (audio or video tag).
  502.  *
  503.  * If the Player is already attached to a media element, the previous element
  504.  * will first be detached.
  505.  *
  506.  * After calling attach, the media element is owned by the Player and should not
  507.  * be used for other purposes until detach or destroy() are called.
  508.  *
  509.  * @param {!HTMLMediaElement} mediaElem
  510.  * @param {boolean=} initializeMediaSource If true, start initializing
  511.  *   MediaSource right away.  This can improve load() latency for
  512.  *   MediaSource-based playbacks.  Defaults to true.
  513.  *
  514.  * @return {!Promise} If initializeMediaSource is false, the Promise is resolved
  515.  *   as soon as the Player has released any previous media element and taken
  516.  *   ownership of the new one.  If initializeMediaSource is true, the Promise
  517.  *   resolves after MediaSource has been subsequently initialized on the new
  518.  *   media element.
  519.  * @export
  520.  */
  521. shaka.Player.prototype.attach =
  522.     async function(mediaElem, initializeMediaSource) {
  523.   if (initializeMediaSource === undefined) {
  524.     initializeMediaSource = true;
  525.   }
  527.   if (this.video_) {
  528.     await this.detach();
  529.   }
  531.   this.video_ = mediaElem;
  532.   goog.asserts.assert(mediaElem, 'Cannot attach to a null media element!');
  534.   // Listen for video errors.
  535.   this.eventManager_.listen(this.video_, 'error',
  536.       this.onVideoError_.bind(this));
  538.   if (initializeMediaSource) {
  539.     // Start the (potentially slow) process of opening MediaSource now.
  540.     this.mediaSourceEngine_ = this.createMediaSourceEngine();
  541.     await this.mediaSourceEngine_.open();
  542.   }
  543. };
  546. /**
  547.  * Detaches the Player from the media element (audio or video tag).
  548.  *
  549.  * After calling detach and waiting for the Promise to be resolved, the media
  550.  * element is no longer owned by the Player and may be used for other purposes.
  551.  *
  552.  * @return {!Promise} Resolved when the Player has released any previous media
  553.  *   element.
  554.  * @export
  555.  */
  556. shaka.Player.prototype.detach = async function() {
  557.   if (!this.video_) {
  558.     return;
  559.   }
  561.   // Unload any loaded content.
  562.   await this.unload(false);
  564.   // Stop listening for video errors.
  565.   this.eventManager_.unlisten(this.video_, 'error');
  567.   this.video_ = null;
  568. };
  571. /**
  572.  * Creates a manifest parser and loads the given manifest.
  573.  *
  574.  * @param {string} manifestUri
  575.  * @param {shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  576.  *   Optional manifest parser factory to override auto-detection or use an
  577.  *   unregistered parser.
  578.  * @return {!Promise.<shakaExtern.Manifest>} Resolves with the manifest.
  579.  * @private
  580.  */
  581. shaka.Player.prototype.loadManifest_ = async function(
  582.     manifestUri, opt_manifestParserFactory) {
  583.   goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  584.   const factory = await shaka.media.ManifestParser.getFactory(
  585.       manifestUri,
  586.       this.networkingEngine_,
  587.       this.config_.manifest.retryParameters,
  588.       opt_manifestParserFactory);
  590.   this.parser_ = new factory();
  591.   this.parser_.configure(this.config_.manifest);
  592.   goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  593.   let playerInterface = {
  594.     networkingEngine: this.networkingEngine_,
  595.     filterNewPeriod: this.filterNewPeriod_.bind(this),
  596.     filterAllPeriods: this.filterAllPeriods_.bind(this),
  597.     onTimelineRegionAdded: this.onTimelineRegionAdded_.bind(this),
  598.     onEvent: this.onEvent_.bind(this),
  599.     onError: this.onError_.bind(this)
  600.   };
  602.   return this.parser_.start(manifestUri, playerInterface);
  603. };
  606. /**
  607.  * When there is a variant with video and audio, filter out all variants which
  608.  * lack one or the other.
  609.  * This is to avoid problems where we choose audio-only variants because they
  610.  * have lower bandwidth, when there are variants with video available.
  611.  *
  612.  * @private
  613.  */
  614. shaka.Player.prototype.filterManifestForAVVariants_ = function() {
  615.   const isAVVariant = (variant) => {
  616.     // Audio-video variants may include both streams separately or may be single
  617.     // multiplexed streams with multiple codecs.
  618.     return (variant.video && variant.audio) ||
  619.            (variant.video && variant.video.codecs.includes(','));
  620.   };
  621.   const hasAVVariant = this.manifest_.periods.some((period) => {
  622.     return period.variants.some(isAVVariant);
  623.   });
  624.   if (hasAVVariant) {
  625.     shaka.log.debug('Found variant with audio and video content, ' +
  626.         'so filtering out audio-only content in all periods.');
  627.     this.manifest_.periods.forEach((period) => {
  628.       period.variants = period.variants.filter(isAVVariant);
  629.     });
  630.   }
  632.   if (this.manifest_.periods.length == 0) {
  633.     throw new shaka.util.Error(
  634.         shaka.util.Error.Severity.CRITICAL,
  635.         shaka.util.Error.Category.MANIFEST,
  636.         shaka.util.Error.Code.NO_PERIODS);
  637.   }
  638. };
  641. /**
  642.  * Applys playRangeStart and playRangeEnd to this.manifest_.
  643.  *
  644.  * @private
  645.  */
  646. shaka.Player.prototype.applyPlayRange_ = function() {
  647.   let fullDuration = this.manifest_.presentationTimeline.getDuration();
  648.   let playRangeEnd = this.config_.playRangeEnd;
  649.   let playRangeStart = this.config_.playRangeStart;
  651.   if (playRangeStart > 0) {
  652.     if (this.isLive()) {
  653.       shaka.log.warning('PlayerConfiguration.playRangeStart has been ' +
  654.                         'configured for live content. Ignoring the setting.');
  655.     } else {
  656.       this.manifest_.presentationTimeline.setUserSeekStart(playRangeStart);
  657.     }
  658.   }
  660.   // If the playback has been configured to end before the end of the
  661.   // presentation, update the duration unless it's live content.
  662.   if (playRangeEnd < fullDuration) {
  663.     if (this.isLive()) {
  664.       shaka.log.warning('PlayerConfiguration.playRangeEnd has been ' +
  665.                         'configured for live content. Ignoring the setting.');
  666.     } else {
  667.       this.manifest_.presentationTimeline.setDuration(playRangeEnd);
  668.     }
  669.   }
  670. };
  673. /**
  674.  * Load a manifest.
  675.  *
  676.  * @param {string} manifestUri
  677.  * @param {number=} opt_startTime Optional start time, in seconds, to begin
  678.  *   playback.
  679.  *   Defaults to 0 for VOD and to the live edge for live.
  680.  *   Set a positive number to start with a certain offset the beginning.
  681.  *   Set a negative number to start with a certain offset from the end.  This is
  682.  *   intended for use with live streams, to start at a fixed offset from the
  683.  *   live edge.
  684.  * @param {shakaExtern.ManifestParser.Factory=} opt_manifestParserFactory
  685.  *   Optional manifest parser factory to override auto-detection or use an
  686.  *   unregistered parser.
  687.  * @return {!Promise} Resolved when the manifest has been loaded and playback
  688.  *   has begun; rejected when an error occurs or the call was interrupted by
  689.  *   destroy(), unload() or another call to load().
  690.  * @export
  691.  */
  692. shaka.Player.prototype.load = async function(manifestUri, opt_startTime,
  693.                                              opt_manifestParserFactory) {
  694.   if (!this.video_) {
  695.     throw new shaka.util.Error(
  696.         shaka.util.Error.Severity.CRITICAL,
  697.         shaka.util.Error.Category.PLAYER,
  698.         shaka.util.Error.Code.NO_VIDEO_ELEMENT);
  699.   }
  701.   let cancelValue;
  702.   /** @type {!shaka.util.PublicPromise} */
  703.   const cancelPromise = new shaka.util.PublicPromise();
  704.   const cancelCallback = function() {
  705.     cancelValue = new shaka.util.Error(
  706.         shaka.util.Error.Severity.CRITICAL,
  707.         shaka.util.Error.Category.PLAYER,
  708.         shaka.util.Error.Code.LOAD_INTERRUPTED);
  709.     return cancelPromise;
  710.   };
  712.   this.dispatchEvent(new shaka.util.FakeEvent('loading'));
  713.   let startTime = Date.now();
  715.   try {
  716.     const unloadPromise = this.unload();
  717.     this.onCancelLoad_ = cancelCallback;
  718.     await unloadPromise;
  720.     // Not tracked in stats because it should be insignificant.
  721.     // Logged in case it is not.
  722.     shaka.log.debug('Unload latency:', (Date.now() - startTime) / 1000);
  724.     this.stats_ = this.getCleanStats_();
  726.     this.eventManager_.listen(this.video_, 'playing',
  727.                               this.updateState_.bind(this));
  728.     this.eventManager_.listen(this.video_, 'pause',
  729.                               this.updateState_.bind(this));
  730.     this.eventManager_.listen(this.video_, 'ended',
  731.                               this.updateState_.bind(this));
  733.     const AbrManagerFactory = this.config_.abrFactory;
  734.     if (!this.abrManager_ || this.abrManagerFactory_ != AbrManagerFactory) {
  735.       this.abrManagerFactory_ = AbrManagerFactory;
  736.       this.abrManager_ = new AbrManagerFactory();
  737.       this.abrManager_.configure(this.config_.abr);
  738.     }
  740.     this.textDisplayer_ = new this.config_.textDisplayFactory();
  741.     this.textDisplayer_.setTextVisibility(this.textVisibility_);
  743.     if (cancelValue) throw cancelValue;
  745.     this.manifest_ = await this.loadManifest_(
  746.         manifestUri, opt_manifestParserFactory);
  747.     this.manifestUri_ = manifestUri;
  749.     if (cancelValue) throw cancelValue;
  751.     this.filterManifestForAVVariants_();
  753.     this.drmEngine_ = this.createDrmEngine();
  754.     this.drmEngine_.configure(this.config_.drm);
  755.     await this.drmEngine_.init(
  756.         /** @type{shakaExtern.Manifest} */ (this.manifest_),
  757.         /* isOffline */ false);
  759.     if (cancelValue) throw cancelValue;
  761.     // Re-filter the manifest after DRM has been initialized.
  762.     this.filterAllPeriods_(this.manifest_.periods);
  764.     this.lastTimeStatsUpdateTimestamp_ = Date.now() / 1000;
  766.     // Copy preferred languages from the config again, in case the config was
  767.     // changed between construction and playback.
  768.     this.currentAudioLanguage_ = this.config_.preferredAudioLanguage;
  769.     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
  770.     this.currentAudioChannelCount_ = this.config_.preferredAudioChannelCount;
  772.     this.applyPlayRange_();
  774.     await this.drmEngine_.attach(this.video_);
  776.     if (cancelValue) throw cancelValue;
  778.     this.abrManager_.init(this.switch_.bind(this));
  780.     if (!this.mediaSourceEngine_) {
  781.       this.mediaSourceEngine_ = this.createMediaSourceEngine();
  782.     }
  784.     this.mediaSourceEngine_.setTextDisplayer(this.textDisplayer_);
  786.     this.playhead_ = this.createPlayhead(opt_startTime);
  787.     this.playheadObserver_ = this.createPlayheadObserver();
  789.     this.streamingEngine_ = this.createStreamingEngine();
  790.     this.streamingEngine_.configure(this.config_.streaming);
  792.     // If the content is multi-codec and the browser can play more than one of
  793.     // them, choose codecs now before we initialize streaming.
  794.     this.chooseCodecsAndFilterManifest_();
  796.     this.dispatchEvent(new shaka.util.FakeEvent('streaming'));
  798.     await this.streamingEngine_.init();
  800.     if (cancelValue) throw cancelValue;
  802.     if (this.config_.streaming.startAtSegmentBoundary) {
  803.       let time = this.adjustStartTime_(this.playhead_.getTime());
  804.       this.playhead_.setStartTime(time);
  805.     }
  807.     // Re-filter the manifest after streams have been chosen.
  808.     this.manifest_.periods.forEach(this.filterNewPeriod_.bind(this));
  809.     // Dispatch a 'trackschanged' event now that all initial filtering is done.
  810.     this.onTracksChanged_();
  811.     // Since the first streams just became active, send an adaptation event.
  812.     this.onAdaptation_();
  814.     // Now that we've filtered out variants that aren't compatible with the
  815.     // active one, update abr manager with filtered variants for the current
  816.     // period.
  817.     let currentPeriod = this.streamingEngine_.getCurrentPeriod();
  818.     let variants = shaka.util.StreamUtils.filterVariantsByConfig(
  819.         currentPeriod.variants, this.currentAudioLanguage_,
  820.         this.currentVariantRole_, this.currentAudioChannelCount_);
  821.     this.abrManager_.setVariants(variants);
  823.     let hasPrimary = currentPeriod.variants.some(function(variant) {
  824.       return variant.primary;
  825.     });
  826.     if (!this.currentAudioLanguage_ && !hasPrimary) {
  827.       shaka.log.warning('No preferred audio language set.  We will choose an ' +
  828.                         'arbitrary language initially');
  829.     }
  831.     this.pendingTimelineRegions_.forEach(
  832.         this.playheadObserver_.addTimelineRegion.bind(this.playheadObserver_));
  833.     this.pendingTimelineRegions_ = [];
  835.     // Wait for the 'loadeddata' event to measure load() latency.
  836.     this.eventManager_.listenOnce(this.video_, 'loadeddata', function() {
  837.       // Compute latency in seconds (Date.now() gives ms):
  838.       let latency = (Date.now() - startTime) / 1000;
  839.       this.stats_.loadLatency = latency;
  840.       shaka.log.debug('Load latency:', latency);
  841.     }.bind(this));
  843.     if (cancelValue) throw cancelValue;
  844.     this.onCancelLoad_ = null;
  845.   } catch (error) {
  846.     goog.asserts.assert(error instanceof shaka.util.Error,
  847.                         'Wrong error type!');
  848.     shaka.log.debug('load() failed:', error,
  849.         error ? error.message : null, error ? error.stack : null);
  851.     // If we haven't started another load, clear the onCancelLoad_.
  852.     cancelPromise.resolve();
  853.     if (this.onCancelLoad_ == cancelCallback) {
  854.       this.onCancelLoad_ = null;
  855.       this.dispatchEvent(new shaka.util.FakeEvent('unloading'));
  856.     }
  858.     // If part of the load chain was aborted, that async call may have thrown.
  859.     // In those cases, we want the cancelation error, not the thrown error.
  860.     if (cancelValue) {
  861.       return Promise.reject(cancelValue);
  862.     }
  863.     return Promise.reject(error);
  864.   }
  865. };
  868. /**
  869.  * In case of multiple usable codecs, choose one based on lowest average
  870.  * bandwidth and filter out the rest.
  871.  * @private
  872.  */
  873. shaka.Player.prototype.chooseCodecsAndFilterManifest_ = function() {
  874.   // Collect a list of variants for all periods.
  875.   /** @type {!Array.<shakaExtern.Variant>} */
  876.   let variants = this.manifest_.periods.reduce(
  877.       (variants, period) => variants.concat(period.variants), []);
  879.   // To start, consider a subset of variants based on audio channel preferences.
  880.   // For some content (#1013), surround-sound variants will use a different
  881.   // codec than stereo variants, so it is important to choose codecs **after**
  882.   // considering the audio channel config.
  883.   variants = shaka.util.StreamUtils.filterVariantsByAudioChannelCount(
  884.       variants, this.config_.preferredAudioChannelCount);
  886.   function variantCodecs(variant) {
  887.     // Only consider the base of the codec string.  For example, these should
  888.     // both be considered the same codec: avc1.42c01e, avc1.4d401f
  889.     let baseVideoCodec =
  890.         variant.video ? variant.video.codecs.split('.')[0] : '';
  891.     let baseAudioCodec =
  892.         variant.audio ? variant.audio.codecs.split('.')[0] : '';
  893.     return baseVideoCodec + '-' + baseAudioCodec;
  894.   }
  896.   // Now organize variants into buckets by codecs.
  897.   /** @type {!Object.<string, !Array.<shakaExtern.Variant>>} */
  898.   let variantsByCodecs = {};
  899.   variants.forEach(function(variant) {
  900.     let codecs = variantCodecs(variant);
  901.     if (!(codecs in variantsByCodecs)) {
  902.       variantsByCodecs[codecs] = [];
  903.     }
  904.     variantsByCodecs[codecs].push(variant);
  905.   });
  907.   // Compute the average bandwidth for each group of variants.
  908.   // Choose the lowest-bandwidth codecs.
  909.   let bestCodecs = null;
  910.   let lowestAverageBandwidth = Infinity;
  911.   shaka.util.MapUtils.forEach(variantsByCodecs, function(codecs, variants) {
  912.     let sum = 0;
  913.     let num = 0;
  914.     variants.forEach(function(variant) {
  915.       sum += variant.bandwidth || 0;
  916.       ++num;
  917.     });
  918.     let averageBandwidth = sum / num;
  919.     shaka.log.debug('codecs', codecs, 'avg bandwidth', averageBandwidth);
  921.     if (averageBandwidth < lowestAverageBandwidth) {
  922.       bestCodecs = codecs;
  923.       lowestAverageBandwidth = averageBandwidth;
  924.     }
  925.   });
  926.   goog.asserts.assert(bestCodecs != null, 'Should have chosen codecs!');
  927.   goog.asserts.assert(!isNaN(lowestAverageBandwidth),
  928.       'Bandwidth should be a number!');
  930.   // Filter out any variants that don't match, forcing AbrManager to choose from
  931.   // the most efficient variants possible.
  932.   this.manifest_.periods.forEach(function(period) {
  933.     period.variants = period.variants.filter(function(variant) {
  934.       let codecs = variantCodecs(variant);
  935.       if (codecs == bestCodecs) return true;
  937.       shaka.log.debug('Dropping Variant (better codec available)', variant);
  938.       return false;
  939.     });
  940.   });
  941. };
  944. /**
  945.  * Creates a new instance of DrmEngine.  This can be replaced by tests to
  946.  * create fake instances instead.
  947.  *
  948.  * @return {!shaka.media.DrmEngine}
  949.  */
  950. shaka.Player.prototype.createDrmEngine = function() {
  951.   goog.asserts.assert(this.networkingEngine_, 'Must not be destroyed');
  953.   let playerInterface = {
  954.     netEngine: this.networkingEngine_,
  955.     onError: this.onError_.bind(this),
  956.     onKeyStatus: this.onKeyStatus_.bind(this),
  957.     onExpirationUpdated: this.onExpirationUpdated_.bind(this),
  958.     onEvent: this.onEvent_.bind(this)
  959.   };
  960.   return new shaka.media.DrmEngine(playerInterface);
  961. };
  964. /**
  965.  * Creates a new instance of NetworkingEngine.  This can be replaced by tests
  966.  * to create fake instances instead.
  967.  *
  968.  * @return {!shaka.net.NetworkingEngine}
  969.  */
  970. shaka.Player.prototype.createNetworkingEngine = function() {
  971.   return new shaka.net.NetworkingEngine(this.onSegmentDownloaded_.bind(this));
  972. };
  975. /**
  976.  * Creates a new instance of Playhead.  This can be replaced by tests to create
  977.  * fake instances instead.
  978.  *
  979.  * @param {number=} opt_startTime
  980.  * @return {!shaka.media.Playhead}
  981.  */
  982. shaka.Player.prototype.createPlayhead = function(opt_startTime) {
  983.   goog.asserts.assert(this.manifest_, 'Must have manifest');
  984.   goog.asserts.assert(this.video_, 'Must have video');
  985.   let startTime = opt_startTime == undefined ? null : opt_startTime;
  986.   return new shaka.media.Playhead(
  987.       this.video_, this.manifest_, this.config_.streaming,
  988.       startTime, this.onSeek_.bind(this), this.onEvent_.bind(this));
  989. };
  992. /**
  993.  * Creates a new instance of PlayheadOvserver.  This can be replaced by tests to
  994.  * create fake instances instead.
  995.  *
  996.  * @return {!shaka.media.PlayheadObserver}
  997.  */
  998. shaka.Player.prototype.createPlayheadObserver = function() {
  999.   goog.asserts.assert(this.manifest_, 'Must have manifest');
  1000.   return new shaka.media.PlayheadObserver(
  1001.       this.video_, this.mediaSourceEngine_, this.manifest_,
  1002.       this.config_.streaming, this.onBuffering_.bind(this),
  1003.       this.onEvent_.bind(this), this.onChangePeriod_.bind(this));
  1004. };
  1007. /**
  1008.  * Creates a new instance of MediaSourceEngine.  This can be replaced by tests
  1009.  * to create fake instances instead.
  1010.  *
  1011.  * @return {!shaka.media.MediaSourceEngine}
  1012.  */
  1013. shaka.Player.prototype.createMediaSourceEngine = function() {
  1014.   return new shaka.media.MediaSourceEngine(this.video_);
  1015. };
  1018. /**
  1019.  * Creates a new instance of StreamingEngine.  This can be replaced by tests
  1020.  * to create fake instances instead.
  1021.  *
  1022.  * @return {!shaka.media.StreamingEngine}
  1023.  */
  1024. shaka.Player.prototype.createStreamingEngine = function() {
  1025.   goog.asserts.assert(
  1026.       this.playhead_ && this.playheadObserver_ && this.mediaSourceEngine_ &&
  1027.           this.manifest_,
  1028.       'Must not be destroyed');
  1030.   let playerInterface = {
  1031.     playhead: this.playhead_,
  1032.     mediaSourceEngine: this.mediaSourceEngine_,
  1033.     netEngine: this.networkingEngine_,
  1034.     onChooseStreams: this.onChooseStreams_.bind(this),
  1035.     onCanSwitch: this.canSwitch_.bind(this),
  1036.     onError: this.onError_.bind(this),
  1037.     onEvent: this.onEvent_.bind(this),
  1038.     onManifestUpdate: this.onManifestUpdate_.bind(this),
  1039.     onSegmentAppended: this.onSegmentAppended_.bind(this),
  1040.     filterNewPeriod: this.filterNewPeriod_.bind(this),
  1041.     filterAllPeriods: this.filterAllPeriods_.bind(this)
  1042.   };
  1043.   return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
  1044. };
  1047. /**
  1048.  * Configure the Player instance.
  1049.  *
  1050.  * The config object passed in need not be complete.  It will be merged with
  1051.  * the existing Player configuration.
  1052.  *
  1053.  * Config keys and types will be checked.  If any problems with the config
  1054.  * object are found, errors will be reported through logs and this returns
  1055.  * false.  If there are errors, valid config objects are still set.
  1056.  *
  1057.  * @param {string|!Object} config This should either be a field name or an
  1058.  *   object following the form of {@link shakaExtern.PlayerConfiguration},
  1059.  *   where you may omit any field you do not wish to change.
  1060.  * @param {*=} value This should be provided if the previous parameter
  1061.  *   was a string field name.
  1062.  * @return {boolean} True if the passed config object was valid, false if there
  1063.  *   were invalid entries.
  1064.  * @export
  1065.  */
  1066. shaka.Player.prototype.configure = function(config, value) {
  1067.   goog.asserts.assert(this.config_, 'Config must not be null!');
  1068.   goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  1069.                       'String configs should have values!');
  1071.   // ('fieldName', value) format
  1072.   if (arguments.length == 2 && typeof(config) == 'string') {
  1073.     config = this.convertToConfigObject_(config, value);
  1074.   }
  1076.   goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  1078.   let ret = shaka.util.ConfigUtils.mergeConfigObjects(
  1079.       this.config_, config, this.defaultConfig_(), this.configOverrides_(), '');
  1081.   this.applyConfig_();
  1082.   return ret;
  1083. };
  1086. /**
  1087.  * Convert config from ('fieldName', value) format to a partial
  1088.  * shakaExtern.PlayerConfiguration object.
  1089.  * E. g. from ('manifest.retryParameters.maxAttempts', 1) to
  1090.  * { manifest: { retryParameters: { maxAttempts: 1 }}}.
  1091.  *
  1092.  * @param {string} fieldName
  1093.  * @param {*} value
  1094.  * @return {!Object}
  1095.  * @private
  1096.  */
  1097. shaka.Player.prototype.convertToConfigObject_ = function(fieldName, value) {
  1098.   let configObject = {};
  1099.   let last = configObject;
  1100.   let searchIndex = 0;
  1101.   let nameStart = 0;
  1102.   while (true) {  // eslint-disable-line no-constant-condition
  1103.     let idx = fieldName.indexOf('.', searchIndex);
  1104.     if (idx < 0) {
  1105.       break;
  1106.     }
  1107.     if (idx == 0 || fieldName[idx - 1] != '\\') {
  1108.       let part = fieldName.substring(nameStart, idx).replace(/\\\./g, '.');
  1109.       last[part] = {};
  1110.       last = last[part];
  1111.       nameStart = idx + 1;
  1112.     }
  1113.     searchIndex = idx + 1;
  1114.   }
  1116.   last[fieldName.substring(nameStart).replace(/\\\./g, '.')] = value;
  1117.   return configObject;
  1118. };
  1121. /**
  1122.  * Apply config changes.
  1123.  * @private
  1124.  */
  1125. shaka.Player.prototype.applyConfig_ = function() {
  1126.   if (this.parser_) {
  1127.     this.parser_.configure(this.config_.manifest);
  1128.   }
  1129.   if (this.drmEngine_) {
  1130.     this.drmEngine_.configure(this.config_.drm);
  1131.   }
  1132.   if (this.streamingEngine_) {
  1133.     this.streamingEngine_.configure(this.config_.streaming);
  1135.     // Need to apply the restrictions to every period.
  1136.     try {
  1137.       // this.filterNewPeriod_() may throw.
  1138.       this.manifest_.periods.forEach(this.filterNewPeriod_.bind(this));
  1139.     } catch (error) {
  1140.       this.onError_(error);
  1141.     }
  1143.     // If the stream we are playing is restricted, we need to switch.
  1144.     let activeAudio = this.streamingEngine_.getActiveAudio();
  1145.     let activeVideo = this.streamingEngine_.getActiveVideo();
  1146.     let period = this.streamingEngine_.getCurrentPeriod();
  1147.     let activeVariant = shaka.util.StreamUtils.getVariantByStreams(
  1148.         activeAudio, activeVideo, period.variants);
  1149.     if (!activeVariant || !activeVariant.allowedByApplication ||
  1150.         !activeVariant.allowedByKeySystem) {
  1151.       shaka.log.debug('Choosing new streams after changing configuration');
  1152.       this.chooseStreamsAndSwitch_(period);
  1153.     }
  1154.   }
  1156.   if (this.abrManager_) {
  1157.     this.abrManager_.configure(this.config_.abr);
  1158.     // Simply enable/disable ABR with each call, since multiple calls to these
  1159.     // methods have no effect.
  1160.     if (this.config_.abr.enabled && !this.switchingPeriods_) {
  1161.       this.abrManager_.enable();
  1162.     } else {
  1163.       this.abrManager_.disable();
  1164.     }
  1165.   }
  1166. };
  1169. /**
  1170.  * Return a copy of the current configuration.  Modifications of the returned
  1171.  * value will not affect the Player's active configuration.  You must call
  1172.  * player.configure() to make changes.
  1173.  *
  1174.  * @return {shakaExtern.PlayerConfiguration}
  1175.  * @export
  1176.  */
  1177. shaka.Player.prototype.getConfiguration = function() {
  1178.   goog.asserts.assert(this.config_, 'Config must not be null!');
  1180.   let ret = this.defaultConfig_();
  1181.   shaka.util.ConfigUtils.mergeConfigObjects(
  1182.       ret, this.config_, this.defaultConfig_(), this.configOverrides_(), '');
  1183.   return ret;
  1184. };
  1187. /**
  1188.  * Reset configuration to default.
  1189.  * @export
  1190.  */
  1191. shaka.Player.prototype.resetConfiguration = function() {
  1192.   // Don't call mergeConfigObjects_(), since that would not reset open-ended
  1193.   // dictionaries like drm.servers.
  1194.   this.config_ = this.defaultConfig_();
  1195.   this.applyConfig_();
  1196. };
  1199. /**
  1200.  * @return {HTMLMediaElement} A reference to the HTML Media Element passed
  1201.  *     to the constructor or to attach().
  1202.  * @export
  1203.  */
  1204. shaka.Player.prototype.getMediaElement = function() {
  1205.   return this.video_;
  1206. };
  1209. /**
  1210.  * @return {shaka.net.NetworkingEngine} A reference to the Player's networking
  1211.  *     engine.  Applications may use this to make requests through Shaka's
  1212.  *     networking plugins.
  1213.  * @export
  1214.  */
  1215. shaka.Player.prototype.getNetworkingEngine = function() {
  1216.   return this.networkingEngine_;
  1217. };
  1220. /**
  1221.  * @return {?string} If a manifest is loaded, returns the manifest URI given in
  1222.  *   the last call to load().  Otherwise, returns null.
  1223.  * @export
  1224.  */
  1225. shaka.Player.prototype.getManifestUri = function() {
  1226.   return this.manifestUri_;
  1227. };
  1230. /**
  1231.  * @return {boolean} True if the current stream is live.  False otherwise.
  1232.  * @export
  1233.  */
  1234. shaka.Player.prototype.isLive = function() {
  1235.   return this.manifest_ ?
  1236.          this.manifest_.presentationTimeline.isLive() :
  1237.          false;
  1238. };
  1241. /**
  1242.  * @return {boolean} True if the current stream is in-progress VOD.
  1243.  *   False otherwise.
  1244.  * @export
  1245.  */
  1246. shaka.Player.prototype.isInProgress = function() {
  1247.   return this.manifest_ ?
  1248.          this.manifest_.presentationTimeline.isInProgress() :
  1249.          false;
  1250. };
  1253. /**
  1254.  * @return {boolean} True for audio-only content.  False otherwise.
  1255.  * @export
  1256.  */
  1257. shaka.Player.prototype.isAudioOnly = function() {
  1258.   if (!this.manifest_ || !this.manifest_.periods.length) {
  1259.     return false;
  1260.   }
  1262.   let variants = this.manifest_.periods[0].variants;
  1263.   if (!variants.length) {
  1264.     return false;
  1265.   }
  1267.   // Note that if there are some audio-only variants and some audio-video
  1268.   // variants, the audio-only variants are removed during filtering.
  1269.   // Therefore if the first variant has no video, that's sufficient to say it
  1270.   // is audio-only content.
  1271.   return !variants[0].video;
  1272. };
  1275. /**
  1276.  * Get the seekable range for the current stream.
  1277.  * @return {{start: number, end: number}}
  1278.  * @export
  1279.  */
  1280. shaka.Player.prototype.seekRange = function() {
  1281.   let start = 0;
  1282.   let end = 0;
  1283.   if (this.manifest_) {
  1284.     let timeline = this.manifest_.presentationTimeline;
  1285.     start = timeline.getSeekRangeStart();
  1286.     end = timeline.getSeekRangeEnd();
  1287.   }
  1288.   return {'start': start, 'end': end};
  1289. };
  1292. /**
  1293.  * Get the key system currently being used by EME.  This returns the empty
  1294.  * string if not using EME.
  1295.  *
  1296.  * @return {string}
  1297.  * @export
  1298.  */
  1299. shaka.Player.prototype.keySystem = function() {
  1300.   return this.drmEngine_ ? this.drmEngine_.keySystem() : '';
  1301. };
  1304. /**
  1305.  * Get the DrmInfo used to initialize EME.  This returns null when not using
  1306.  * EME.
  1307.  *
  1308.  * @return {?shakaExtern.DrmInfo}
  1309.  * @export
  1310.  */
  1311. shaka.Player.prototype.drmInfo = function() {
  1312.   return this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  1313. };
  1316. /**
  1317.  * The next known expiration time for any EME session.  If the sessions never
  1318.  * expire, or there are no EME sessions, this returns Infinity.
  1319.  *
  1320.  * @return {number}
  1321.  * @export
  1322.  */
  1323. shaka.Player.prototype.getExpiration = function() {
  1324.   return this.drmEngine_ ? this.drmEngine_.getExpiration() : Infinity;
  1325. };
  1328. /**
  1329.  * @return {boolean} True if the Player is in a buffering state.
  1330.  * @export
  1331.  */
  1332. shaka.Player.prototype.isBuffering = function() {
  1333.   return this.buffering_;
  1334. };
  1337. /**
  1338.  * Unload the current manifest and make the Player available for re-use.
  1339.  *
  1340.  * @param {boolean=} reinitializeMediaSource If true, start reinitializing
  1341.  *   MediaSource right away.  This can improve load() latency for
  1342.  *   MediaSource-based playbacks.  Defaults to true.
  1343.  * @return {!Promise} If reinitializeMediaSource is false, the Promise is
  1344.  *   resolved as soon as streaming has stopped and the previous content, if any,
  1345.  *   has been unloaded.  If reinitializeMediaSource is true or undefined, the
  1346.  *   Promise resolves after MediaSource has been subsequently reinitialized.
  1347.  * @export
  1348.  */
  1349. shaka.Player.prototype.unload = async function(reinitializeMediaSource) {
  1350.   if (this.destroyed_) {
  1351.     return;
  1352.   }
  1354.   if (reinitializeMediaSource === undefined) {
  1355.     reinitializeMediaSource = true;
  1356.   }
  1358.   this.dispatchEvent(new shaka.util.FakeEvent('unloading'));
  1360.   await this.cancelLoad_();
  1362.   // If there is an existing unload operation, use that.
  1363.   if (!this.unloadChain_) {
  1364.     this.unloadChain_ = this.destroyStreaming_().then(() => {
  1365.       // Force an exit from the buffering state.
  1366.       this.onBuffering_(false);
  1367.       this.unloadChain_ = null;
  1368.     });
  1369.   }
  1370.   await this.unloadChain_;
  1372.   if (reinitializeMediaSource) {
  1373.     // Start the (potentially slow) process of opening MediaSource now.
  1374.     this.mediaSourceEngine_ = this.createMediaSourceEngine();
  1375.     await this.mediaSourceEngine_.open();
  1376.   }
  1377. };
  1380. /**
  1381.  * Gets the current effective playback rate.  If using trick play, it will
  1382.  * return the current trick play rate; otherwise, it will return the video
  1383.  * playback rate.
  1384.  * @return {number}
  1385.  * @export
  1386.  */
  1387. shaka.Player.prototype.getPlaybackRate = function() {
  1388.   return this.playhead_ ? this.playhead_.getPlaybackRate() : 0;
  1389. };
  1392. /**
  1393.  * Skip through the content without playing.  Simulated using repeated seeks.
  1394.  *
  1395.  * Trick play will be canceled automatically if the playhead hits the beginning
  1396.  * or end of the seekable range for the content.
  1397.  *
  1398.  * @param {number} rate The playback rate to simulate.  For example, a rate of
  1399.  *     2.5 would result in 2.5 seconds of content being skipped every second.
  1400.  *     To trick-play backward, use a negative rate.
  1401.  * @export
  1402.  */
  1403. shaka.Player.prototype.trickPlay = function(rate) {
  1404.   shaka.log.debug('Trick play rate', rate);
  1405.   if (this.playhead_) {
  1406.     this.playhead_.setPlaybackRate(rate);
  1407.   }
  1409.   if (this.streamingEngine_) {
  1410.     this.streamingEngine_.setTrickPlay(rate != 1);
  1411.   }
  1412. };
  1415. /**
  1416.  * Cancel trick-play.
  1417.  * @export
  1418.  */
  1419. shaka.Player.prototype.cancelTrickPlay = function() {
  1420.   shaka.log.debug('Trick play canceled');
  1421.   if (this.playhead_) {
  1422.     this.playhead_.setPlaybackRate(1);
  1423.   }
  1425.   if (this.streamingEngine_) {
  1426.     this.streamingEngine_.setTrickPlay(false);
  1427.   }
  1428. };
  1431. /**
  1432.  * Return a list of variant tracks available for the current
  1433.  * Period.  If there are multiple Periods, then you must seek to the Period
  1434.  * before being able to switch.
  1435.  *
  1436.  * @return {!Array.<shakaExtern.Track>}
  1437.  * @export
  1438.  */
  1439. shaka.Player.prototype.getVariantTracks = function() {
  1440.   if (!this.manifest_ || !this.playhead_) {
  1441.     return [];
  1442.   }
  1443.   this.assertCorrectActiveStreams_();
  1445.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1447.   let currentPeriod = shaka.util.StreamUtils.findPeriodContainingTime(
  1448.       this.manifest_, this.playhead_.getTime());
  1449.   let activeStreams = this.activeStreamsByPeriod_[currentPeriod] || {};
  1450.   return shaka.util.StreamUtils.getVariantTracks(
  1451.       this.manifest_.periods[currentPeriod],
  1452.       activeStreams[ContentType.AUDIO],
  1453.       activeStreams[ContentType.VIDEO]);
  1454. };
  1457. /**
  1458.  * Return a list of text tracks available for the current
  1459.  * Period.  If there are multiple Periods, then you must seek to the Period
  1460.  * before being able to switch.
  1461.  *
  1462.  * @return {!Array.<shakaExtern.Track>}
  1463.  * @export
  1464.  */
  1465. shaka.Player.prototype.getTextTracks = function() {
  1466.   if (!this.manifest_ || !this.playhead_) {
  1467.     return [];
  1468.   }
  1469.   this.assertCorrectActiveStreams_();
  1471.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1472.   let currentPeriod = shaka.util.StreamUtils.findPeriodContainingTime(
  1473.       this.manifest_, this.playhead_.getTime());
  1474.   let activeStreams = this.activeStreamsByPeriod_[currentPeriod] || {};
  1475.   if (!activeStreams[ContentType.TEXT]) {
  1476.     // This is a workaround for the demo page to be able to display the
  1477.     // list of text tracks. If no text track is currently active, pick
  1478.     // the one that's going to be streamed when captions are enabled
  1479.     // and mark it as active.
  1480.     let textStreams = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  1481.         this.manifest_.periods[currentPeriod].textStreams,
  1482.         this.currentTextLanguage_,
  1483.         this.currentTextRole_);
  1484.     if (textStreams.length) {
  1485.       activeStreams[ContentType.TEXT] = textStreams[0].id;
  1486.     }
  1487.   }
  1488.   return shaka.util.StreamUtils
  1489.       .getTextTracks(
  1490.           this.manifest_.periods[currentPeriod],
  1491.           activeStreams[ContentType.TEXT])
  1492.       .filter(function(track) {
  1493.         // Don't show any tracks that are being loaded still.
  1494.         return this.loadingTextStreamIds_.indexOf(track.id) < 0;
  1495.       }.bind(this));
  1496. };
  1499. /**
  1500.  * Select a specific text track.  Note that AdaptationEvents are not
  1501.  * fired for manual track selections.
  1502.  *
  1503.  * @param {shakaExtern.Track} track
  1504.  * @export
  1505.  */
  1506. shaka.Player.prototype.selectTextTrack = function(track) {
  1507.   if (!this.streamingEngine_) {
  1508.     return;
  1509.   }
  1511.   const StreamUtils = shaka.util.StreamUtils;
  1513.   let period = this.streamingEngine_.getCurrentPeriod();
  1514.   let stream = StreamUtils.findTextStreamForTrack(period, track);
  1516.   if (!stream) {
  1517.     shaka.log.error('Unable to find the track with id "' + track.id +
  1518.                     '"; did we change Periods?');
  1519.     return;
  1520.   }
  1522.   this.mediaSourceEngine_.setUseEmbeddedText(false);
  1523.   // Add entries to the history.
  1524.   this.addTextStreamToSwitchHistory_(stream, /* fromAdaptation */ false);
  1525.   this.switchTextStream_(stream);
  1527.   // Workaround for https://github.com/google/shaka-player/issues/1299
  1528.   // When track is selected, back-propogate the language to
  1529.   // currentTextLanguage_.
  1530.   this.currentTextLanguage_ = stream.language;
  1531. };
  1534. /**
  1535.  * Use the embedded text for the current stream, if present.
  1536.  *
  1537.  * CEA 608/708 captions data is embedded inside the video stream.
  1538.  *
  1539.  * @export
  1540.  */
  1541. shaka.Player.prototype.selectEmbeddedTextTrack = function() {
  1542.   this.mediaSourceEngine_.setUseEmbeddedText(true);
  1543.   this.streamingEngine_.unloadTextStream();
  1544. };
  1547. /**
  1548.  * @return {boolean} True if we are using any embedded text tracks present.
  1549.  * @export
  1550.  */
  1551. shaka.Player.prototype.usingEmbeddedTextTrack = function() {
  1552.   return this.mediaSourceEngine_ ?
  1553.       this.mediaSourceEngine_.getUseEmbeddedText() : false;
  1554. };
  1557. /**
  1558.  * Select a specific track.  Note that AdaptationEvents are not fired for manual
  1559.  * track selections.
  1560.  *
  1561.  * @param {shakaExtern.Track} track
  1562.  * @param {boolean=} opt_clearBuffer
  1563.  * @export
  1564.  */
  1565. shaka.Player.prototype.selectVariantTrack = function(track, opt_clearBuffer) {
  1566.   if (!this.streamingEngine_) {
  1567.     return;
  1568.   }
  1570.   if (this.config_.abr.enabled) {
  1571.     shaka.log.alwaysWarn('Changing tracks while abr manager is enabled will ' +
  1572.                          'likely result in the selected track being ' +
  1573.                          'overriden. Consider disabling abr before calling ' +
  1574.                          'selectVariantTrack().');
  1575.   }
  1577.   const StreamUtils = shaka.util.StreamUtils;
  1579.   let period = this.streamingEngine_.getCurrentPeriod();
  1580.   let variant = StreamUtils.findVariantForTrack(period, track);
  1581.   if (!variant) {
  1582.     shaka.log.error('Unable to locate track with id "' + track.id + '".');
  1583.     return;
  1584.   }
  1586.   // Double check that the track is allowed to be played.
  1587.   // The track list should only contain playable variants,
  1588.   // but if restrictions change and selectVariantTrack()
  1589.   // is called before the track list is updated, we could
  1590.   // get a now-restricted variant.
  1591.   let variantIsPlayable = StreamUtils.isPlayable(variant);
  1592.   if (!variantIsPlayable) {
  1593.     shaka.log.error('Unable to switch to track with id "' + track.id +
  1594.                     '" because it is restricted.');
  1595.     return;
  1596.   }
  1598.   // Add entries to the history.
  1599.   this.addVariantToSwitchHistory_(variant, /* fromAdaptation */ false);
  1600.   this.switchVariant_(variant, opt_clearBuffer);
  1602.   // Workaround for https://github.com/google/shaka-player/issues/1299
  1603.   // When track is selected, back-propogate the language to
  1604.   // currentAudioLanguage_.
  1605.   this.currentAudioLanguage_ = variant.language;
  1606.   if (variant.audio && variant.audio.channelsCount) {
  1607.     this.currentAudioChannelCount_ = variant.audio.channelsCount;
  1608.   }
  1610.   // Update AbrManager variants to match these new settings.
  1611.   let variants = shaka.util.StreamUtils.filterVariantsByConfig(
  1612.       period.variants, this.currentAudioLanguage_, this.currentVariantRole_,
  1613.       this.currentAudioChannelCount_);
  1614.   this.abrManager_.setVariants(variants);
  1615. };
  1618. /**
  1619.  * Return a list of audio language-role combinations available for the current
  1620.  * Period.
  1621.  *
  1622.  * @return {!Array.<shakaExtern.LanguageRole>}
  1623.  * @export
  1624.  */
  1625. shaka.Player.prototype.getAudioLanguagesAndRoles = function() {
  1626.   if (!this.streamingEngine_) {
  1627.     return [];
  1628.   }
  1630.   const StreamUtils = shaka.util.StreamUtils;
  1631.   let period = this.streamingEngine_.getCurrentPeriod();
  1632.   let variants = StreamUtils.getPlayableVariants(period.variants);
  1633.   let audioStreams = variants.map(function(variant) {
  1634.     return variant.audio;
  1635.   }).filter(shaka.util.Functional.isNotDuplicate);
  1637.   return this.getLanguagesAndRoles_(audioStreams);
  1638. };
  1641. /**
  1642.  * Return a list of text language-role combinations available for the current
  1643.  * Period.
  1644.  *
  1645.  * @return {!Array.<shakaExtern.LanguageRole>}
  1646.  * @export
  1647.  */
  1648. shaka.Player.prototype.getTextLanguagesAndRoles = function() {
  1649.   if (!this.streamingEngine_) {
  1650.     return [];
  1651.   }
  1653.   let period = this.streamingEngine_.getCurrentPeriod();
  1654.   return this.getLanguagesAndRoles_(period.textStreams);
  1655. };
  1658. /**
  1659.  * Return a list of audio languages available for the current Period.
  1660.  *
  1661.  * @return {!Array.<string>}
  1662.  * @export
  1663.  */
  1664. shaka.Player.prototype.getAudioLanguages = function() {
  1665.   if (!this.streamingEngine_) {
  1666.     return [];
  1667.   }
  1669.   const StreamUtils = shaka.util.StreamUtils;
  1670.   let period = this.streamingEngine_.getCurrentPeriod();
  1671.   let variants = StreamUtils.getPlayableVariants(period.variants);
  1672.   return variants.map(function(variant) {
  1673.     return variant.language;
  1674.   }).filter(shaka.util.Functional.isNotDuplicate);
  1675. };
  1678. /**
  1679.  * Return a list of text languages available for the current Period.
  1680.  *
  1681.  * @return {!Array.<string>}
  1682.  * @export
  1683.  */
  1684. shaka.Player.prototype.getTextLanguages = function() {
  1685.   if (!this.streamingEngine_) {
  1686.     return [];
  1687.   }
  1689.   let period = this.streamingEngine_.getCurrentPeriod();
  1690.   return period.textStreams.map(function(stream) {
  1691.     return stream.language;
  1692.   }).filter(shaka.util.Functional.isNotDuplicate);
  1693. };
  1696. /**
  1697.  * Given a list of streams, return a list of language-role combinations
  1698.  * available for them.
  1699.  *
  1700.  * @param {!Array.<?shakaExtern.Stream>} streams
  1701.  * @return {!Array.<shakaExtern.LanguageRole>}
  1702.  * @private
  1703.  */
  1704. shaka.Player.prototype.getLanguagesAndRoles_ = function(streams) {
  1705.   /** @const {string} */
  1706.   const noLanguage = 'und';
  1708.   /** @const {string} */
  1709.   const noRole = '';
  1711.   /** @type {!Array.<shakaExtern.LanguageRole>} */
  1712.   let roleLangCombinations = [];
  1714.   streams.forEach(function(stream) {
  1715.     if (!stream) {
  1716.       // Video-only variant
  1717.       roleLangCombinations.push({language: noLanguage, role: noRole});
  1718.     } else {
  1719.       let language = stream.language;
  1721.       if (stream.roles.length) {
  1722.         stream.roles.forEach(function(role) {
  1723.           roleLangCombinations.push({language: language, role: role});
  1724.         });
  1725.       } else {
  1726.         // No roles, just add language by itself
  1727.         roleLangCombinations.push({language: language, role: noRole});
  1728.       }
  1729.     }
  1730.   });
  1731.   return shaka.util.ArrayUtils.removeDuplicates(
  1732.       roleLangCombinations,
  1733.       function(a, b) {
  1734.         return a.language == b.language && a.role == b.role;
  1735.       });
  1736. };
  1739. /**
  1740.  * Sets currentAudioLanguage and currentVariantRole to the selected
  1741.  * language and role, and chooses a new variant if need be.
  1742.  *
  1743.  * @param {string} language
  1744.  * @param {string=} opt_role
  1745.  * @export
  1746.  */
  1747. shaka.Player.prototype.selectAudioLanguage =
  1748.     function(language, opt_role) {
  1749.   if (!this.streamingEngine_) return;
  1750.   let period = this.streamingEngine_.getCurrentPeriod();
  1751.   this.currentAudioLanguage_ = language;
  1752.   this.currentVariantRole_ = opt_role || '';
  1753.   // TODO: Refactor to only change audio and not affect text.
  1754.   this.chooseStreamsAndSwitch_(period);
  1755. };
  1758. /**
  1759.  * Sets currentTextLanguage and currentTextRole to the selected
  1760.  * language and role, and chooses a new text stream if need be.
  1761.  *
  1762.  * @param {string} language
  1763.  * @param {string=} opt_role
  1764.  * @export
  1765.  */
  1766. shaka.Player.prototype.selectTextLanguage =
  1767.     function(language, opt_role) {
  1768.   if (!this.streamingEngine_) return;
  1769.   let period = this.streamingEngine_.getCurrentPeriod();
  1770.   this.currentTextLanguage_ = language;
  1771.   this.currentTextRole_ = opt_role || '';
  1772.   // TODO: Refactor to only change text and not affect audio.
  1773.   this.chooseStreamsAndSwitch_(period);
  1774. };
  1777. /**
  1778.  * @return {boolean} True if the current text track is visible.
  1779.  * @export
  1780.  */
  1781. shaka.Player.prototype.isTextTrackVisible = function() {
  1782.   if (this.textDisplayer_) {
  1783.     return this.textDisplayer_.isTextVisible();
  1784.   } else {
  1785.     return this.textVisibility_;
  1786.   }
  1787. };
  1790. /**
  1791.  * Set the visibility of the current text track, if any.
  1792.  *
  1793.  * @param {boolean} on
  1794.  * @export
  1795.  */
  1796. shaka.Player.prototype.setTextTrackVisibility = function(on) {
  1797.   if (this.textDisplayer_) {
  1798.     this.textDisplayer_.setTextVisibility(on);
  1799.   }
  1800.   this.textVisibility_ = on;
  1801.   this.onTextTrackVisibility_();
  1803.   // If we always stream text, don't do anything special to StreamingEngine.
  1804.   if (this.config_.streaming.alwaysStreamText) return;
  1806.   // Load text stream when the user chooses to show the caption, and pause
  1807.   // loading text stream when the user chooses to hide the caption.
  1808.   if (!this.streamingEngine_) return;
  1809.   const StreamUtils = shaka.util.StreamUtils;
  1811.   if (on) {
  1812.     let period = this.streamingEngine_.getCurrentPeriod();
  1813.     let textStreams = StreamUtils.filterStreamsByLanguageAndRole(
  1814.         period.textStreams,
  1815.         this.currentTextLanguage_,
  1816.         this.currentTextRole_);
  1817.     let stream = textStreams[0];
  1818.     if (stream) {
  1819.       this.streamingEngine_.loadNewTextStream(stream);
  1820.     }
  1821.   } else {
  1822.     this.streamingEngine_.unloadTextStream();
  1823.   }
  1824. };
  1827. /**
  1828.  * Returns current playhead time as a Date.
  1829.  *
  1830.  * @return {Date}
  1831.  * @export
  1832.  */
  1833. shaka.Player.prototype.getPlayheadTimeAsDate = function() {
  1834.   if (!this.manifest_) return null;
  1836.   goog.asserts.assert(this.isLive(),
  1837.       'getPlayheadTimeAsDate should be called on a live stream!');
  1839.   let time =
  1840.       this.manifest_.presentationTimeline.getPresentationStartTime() * 1000 +
  1841.       this.video_.currentTime * 1000;
  1843.   return new Date(time);
  1844. };
  1847. /**
  1848.  * Returns the presentation start time as a Date.
  1849.  *
  1850.  * @return {Date}
  1851.  * @export
  1852.  */
  1853. shaka.Player.prototype.getPresentationStartTimeAsDate = function() {
  1854.   if (!this.manifest_) return null;
  1856.   goog.asserts.assert(this.isLive(),
  1857.       'getPresentationStartTimeAsDate should be called on a live stream!');
  1859.   let time =
  1860.       this.manifest_.presentationTimeline.getPresentationStartTime() * 1000;
  1862.   return new Date(time);
  1863. };
  1866. /**
  1867.  * Return the information about the current buffered ranges.
  1868.  *
  1869.  * @return {shakaExtern.BufferedInfo}
  1870.  * @export
  1871.  */
  1872. shaka.Player.prototype.getBufferedInfo = function() {
  1873.   if (!this.mediaSourceEngine_) {
  1874.     return {
  1875.       total: [],
  1876.       audio: [],
  1877.       video: [],
  1878.       text: []
  1879.     };
  1880.   }
  1882.   return this.mediaSourceEngine_.getBufferedInfo();
  1883. };
  1886. /**
  1887.  * Return playback and adaptation stats.
  1888.  *
  1889.  * @return {shakaExtern.Stats}
  1890.  * @export
  1891.  */
  1892. shaka.Player.prototype.getStats = function() {
  1893.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1895.   this.updateTimeStats_();
  1896.   this.updateState_();
  1898.   let video = null;
  1899.   let variant = null;
  1901.   let videoElem = /** @type {!HTMLVideoElement} */ (this.video_);
  1902.   let videoInfo = videoElem && videoElem.getVideoPlaybackQuality ?
  1903.       videoElem.getVideoPlaybackQuality() : {};
  1905.   if (this.playhead_ && this.manifest_) {
  1906.     let periodIdx = shaka.util.StreamUtils.findPeriodContainingTime(
  1907.         this.manifest_, this.playhead_.getTime());
  1908.     let period = this.manifest_.periods[periodIdx];
  1909.     let activeStreams = this.activeStreamsByPeriod_[periodIdx];
  1911.     if (activeStreams) {
  1912.       variant = shaka.util.StreamUtils.getVariantByStreamIds(
  1913.           activeStreams[ContentType.AUDIO],
  1914.           activeStreams[ContentType.VIDEO],
  1915.           period.variants);
  1917.       // |variant| can possibly be null, if the period contains a text stream
  1918.       // but no video or audio streams.
  1919.       video = variant ? variant.video : null;
  1920.     }
  1921.   }
  1923.   if (!video) video = {};
  1924.   if (!variant) variant = {};
  1926.   // Clone the internal object so our state cannot be tampered with.
  1927.   const cloneObject = shaka.util.ConfigUtils.cloneObject;
  1928.   return {
  1929.     // Not tracked in this.stats_:
  1930.     width: video.width || 0,
  1931.     height: video.height || 0,
  1932.     streamBandwidth: variant.bandwidth || 0,
  1933.     decodedFrames: Number(videoInfo.totalVideoFrames),
  1934.     droppedFrames: Number(videoInfo.droppedVideoFrames),
  1935.     estimatedBandwidth: this.abrManager_ ?
  1936.         this.abrManager_.getBandwidthEstimate() : NaN,
  1938.     loadLatency: this.stats_.loadLatency,
  1939.     playTime: this.stats_.playTime,
  1940.     bufferingTime: this.stats_.bufferingTime,
  1941.     // Deep-clone the objects as well as the arrays that contain them:
  1942.     switchHistory: cloneObject(this.stats_.switchHistory),
  1943.     stateHistory: cloneObject(this.stats_.stateHistory)
  1944.   };
  1945. };
  1948. /**
  1949.  * Adds the given text track to the current Period.  load() must resolve before
  1950.  * calling.  The current Period or the presentation must have a duration.  This
  1951.  * returns a Promise that will resolve with the track that was created, when
  1952.  * that track can be switched to.
  1953.  *
  1954.  * @param {string} uri
  1955.  * @param {string} language
  1956.  * @param {string} kind
  1957.  * @param {string} mime
  1958.  * @param {string=} opt_codec
  1959.  * @param {string=} opt_label
  1960.  * @return {!Promise.<shakaExtern.Track>}
  1961.  * @export
  1962.  */
  1963. shaka.Player.prototype.addTextTrack = function(
  1964.     uri, language, kind, mime, opt_codec, opt_label) {
  1965.   if (!this.streamingEngine_) {
  1966.     shaka.log.error(
  1967.         'Must call load() and wait for it to resolve before adding text ' +
  1968.         'tracks.');
  1969.     return Promise.reject();
  1970.   }
  1972.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1974.   // Get the Period duration.
  1975.   let period = this.streamingEngine_.getCurrentPeriod();
  1976.   /** @type {number} */
  1977.   const periodIndex = this.manifest_.periods.indexOf(period);
  1978.   /** @type {number} */
  1979.   const nextPeriodIndex = periodIndex + 1;
  1980.   /** @type {number} */
  1981.   const nextPeriodStart = nextPeriodIndex >= this.manifest_.periods.length ?
  1982.                           this.manifest_.presentationTimeline.getDuration() :
  1983.                           this.manifest_.periods[nextPeriodIndex].startTime;
  1984.   /** @type {number} */
  1985.   const periodDuration = nextPeriodStart - period.startTime;
  1986.   if (periodDuration == Infinity) {
  1987.     return Promise.reject(new shaka.util.Error(
  1988.         shaka.util.Error.Severity.RECOVERABLE,
  1989.         shaka.util.Error.Category.MANIFEST,
  1990.         shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_LIVE_STREAM));
  1991.   }
  1993.   /** @type {shakaExtern.Stream} */
  1994.   let stream = {
  1995.     id: this.nextExternalStreamId_++,
  1996.     createSegmentIndex: Promise.resolve.bind(Promise),
  1997.     findSegmentPosition: function(time) { return 1; },
  1998.     getSegmentReference: function(ref) {
  1999.       if (ref != 1) return null;
  2000.       return new shaka.media.SegmentReference(
  2001.           1, 0, periodDuration, function() { return [uri]; }, 0, null);
  2002.     },
  2003.     initSegmentReference: null,
  2004.     presentationTimeOffset: 0,
  2005.     mimeType: mime,
  2006.     codecs: opt_codec || '',
  2007.     kind: kind,
  2008.     encrypted: false,
  2009.     keyId: null,
  2010.     language: language,
  2011.     label: opt_label || null,
  2012.     type: ContentType.TEXT,
  2013.     primary: false,
  2014.     trickModeVideo: null,
  2015.     containsEmsgBoxes: false,
  2016.     roles: [],
  2017.     channelsCount: null
  2018.   };
  2020.   // Add the stream to the loading list to ensure it isn't switched to while it
  2021.   // is initializing.
  2022.   this.loadingTextStreamIds_.push(stream.id);
  2023.   period.textStreams.push(stream);
  2024.   // Don't create the media state until subtitles are actually enabled
  2025.   return this.streamingEngine_.loadNewTextStream(stream).then(function() {
  2026.     if (this.destroyed_) return;
  2028.     let curPeriodIdx = this.manifest_.periods.indexOf(period);
  2029.     let activeText = this.streamingEngine_.getActiveText();
  2030.     if (activeText) {
  2031.       // If this was the first text stream, StreamingEngine will start streaming
  2032.       // it in loadNewTextStream.  To reflect this, update the active stream.
  2033.       this.activeStreamsByPeriod_[curPeriodIdx][ContentType.TEXT] =
  2034.           activeText.id;
  2035.     }
  2036.     // Remove the stream from the loading list.
  2037.     this.loadingTextStreamIds_.splice(
  2038.         this.loadingTextStreamIds_.indexOf(stream.id), 1);
  2040.     shaka.log.debug('Choosing new streams after adding a text stream');
  2041.     this.chooseStreamsAndSwitch_(period);
  2042.     this.onTracksChanged_();
  2044.     return {
  2045.       id: stream.id,
  2046.       active: false,
  2047.       type: ContentType.TEXT,
  2048.       bandwidth: 0,
  2049.       language: language,
  2050.       label: opt_label || null,
  2051.       kind: kind,
  2052.       width: null,
  2053.       height: null
  2054.     };
  2055.   }.bind(this));
  2056. };
  2059. /**
  2060.  * Set the maximum resolution that the platform's hardware can handle.
  2061.  * This will be called automatically by shaka.cast.CastReceiver to enforce
  2062.  * limitations of the Chromecast hardware.
  2063.  *
  2064.  * @param {number} width
  2065.  * @param {number} height
  2066.  * @export
  2067.  */
  2068. shaka.Player.prototype.setMaxHardwareResolution = function(width, height) {
  2069.   this.maxHwRes_.width = width;
  2070.   this.maxHwRes_.height = height;
  2071. };
  2074. /**
  2075.  * Retry streaming after a failure.  Does nothing if not in a failure state.
  2076.  * @return {boolean} False if unable to retry.
  2077.  * @export
  2078.  */
  2079. shaka.Player.prototype.retryStreaming = function() {
  2080.   return this.streamingEngine_ ? this.streamingEngine_.retry() : false;
  2081. };
  2084. /**
  2085.  * Return the manifest information if it's loaded. Otherwise, return null.
  2086.  * @return {?shakaExtern.Manifest}
  2087.  * @export
  2088.  */
  2089. shaka.Player.prototype.getManifest = function() {
  2090.   return this.manifest_;
  2091. };
  2094. /**
  2095.  * @param {shakaExtern.Variant} variant
  2096.  * @param {boolean} fromAdaptation
  2097.  * @private
  2098.  */
  2099. shaka.Player.prototype.addVariantToSwitchHistory_ = function(
  2100.     variant, fromAdaptation) {
  2101.   if (variant.video) {
  2102.     this.updateActiveStreams_(variant.video);
  2103.   }
  2104.   if (variant.audio) {
  2105.     this.updateActiveStreams_(variant.audio);
  2106.   }
  2108.   // TODO: Get StreamingEngine to track variants and create getActiveVariant()
  2109.   let activePeriod = this.streamingEngine_.getActivePeriod();
  2110.   let activeVariant = shaka.util.StreamUtils.getVariantByStreams(
  2111.       this.streamingEngine_.getActiveAudio(),
  2112.       this.streamingEngine_.getActiveVideo(),
  2113.       activePeriod ? activePeriod.variants : []);
  2115.   // Only log the switch if the variant changes. For the initial decision,
  2116.   // activeVariant is null and variant != activeVariant.
  2117.   // This allows us to avoid onAdaptation_() when nothing has changed.
  2118.   if (variant != activeVariant) {
  2119.     this.stats_.switchHistory.push({
  2120.       timestamp: Date.now() / 1000,
  2121.       id: variant.id,
  2122.       type: 'variant',
  2123.       fromAdaptation: fromAdaptation,
  2124.       bandwidth: variant.bandwidth
  2125.     });
  2126.   }
  2127. };
  2130. /**
  2131.  * @param {shakaExtern.Stream} textStream
  2132.  * @param {boolean} fromAdaptation
  2133.  * @private
  2134.  */
  2135. shaka.Player.prototype.addTextStreamToSwitchHistory_ =
  2136.     function(textStream, fromAdaptation) {
  2137.   this.updateActiveStreams_(textStream);
  2139.   this.stats_.switchHistory.push({
  2140.     timestamp: Date.now() / 1000,
  2141.     id: textStream.id,
  2142.     type: 'text',
  2143.     fromAdaptation: fromAdaptation,
  2144.     bandwidth: null
  2145.   });
  2146. };
  2149. /**
  2150.  * @param {!shakaExtern.Stream} stream
  2151.  * @private
  2152.  */
  2153. shaka.Player.prototype.updateActiveStreams_ = function(stream) {
  2154.   goog.asserts.assert(this.manifest_, 'Must not be destroyed');
  2155.   let periodIndex =
  2156.       shaka.util.StreamUtils.findPeriodContainingStream(this.manifest_, stream);
  2157.   if (!this.activeStreamsByPeriod_[periodIndex]) {
  2158.     this.activeStreamsByPeriod_[periodIndex] = {};
  2159.   }
  2160.   this.activeStreamsByPeriod_[periodIndex][stream.type] = stream.id;
  2161. };
  2164. /**
  2165.  * Destroy members responsible for streaming.
  2166.  *
  2167.  * @return {!Promise}
  2168.  * @private
  2169.  */
  2170. shaka.Player.prototype.destroyStreaming_ = function() {
  2171.   if (this.eventManager_) {
  2172.     this.eventManager_.unlisten(this.video_, 'loadeddata');
  2173.     this.eventManager_.unlisten(this.video_, 'playing');
  2174.     this.eventManager_.unlisten(this.video_, 'pause');
  2175.     this.eventManager_.unlisten(this.video_, 'ended');
  2176.   }
  2178.   const drmEngine = this.drmEngine_;
  2179.   let p = Promise.all([
  2180.     this.abrManager_ ? this.abrManager_.stop() : null,
  2181.     this.mediaSourceEngine_ ? this.mediaSourceEngine_.destroy() : null,
  2182.     this.playhead_ ? this.playhead_.destroy() : null,
  2183.     this.playheadObserver_ ? this.playheadObserver_.destroy() : null,
  2184.     this.streamingEngine_ ? this.streamingEngine_.destroy() : null,
  2185.     this.parser_ ? this.parser_.stop() : null,
  2186.     this.textDisplayer_ ? this.textDisplayer_.destroy() : null,
  2187.   ]).then(() => {
  2188.     // MediaSourceEngine must be destroyed before DrmEngine, so that DrmEngine
  2189.     // can detach MediaKeys from the media element.
  2190.     return drmEngine ? drmEngine.destroy() : null;
  2191.   });
  2193.   this.switchingPeriods_ = true;
  2194.   this.drmEngine_ = null;
  2195.   this.mediaSourceEngine_ = null;
  2196.   this.playhead_ = null;
  2197.   this.playheadObserver_ = null;
  2198.   this.streamingEngine_ = null;
  2199.   this.parser_ = null;
  2200.   this.textDisplayer_ = null;
  2201.   this.manifest_ = null;
  2202.   this.manifestUri_ = null;
  2203.   this.pendingTimelineRegions_ = [];
  2204.   this.activeStreamsByPeriod_ = {};
  2205.   this.stats_ = this.getCleanStats_();
  2207.   return p;
  2208. };
  2211. /**
  2212.  * @return {!Object}
  2213.  * @private
  2214.  */
  2215. shaka.Player.prototype.configOverrides_ = function() {
  2216.   return {
  2217.     '.drm.servers': '',
  2218.     '.drm.clearKeys': '',
  2219.     '.drm.advanced': {
  2220.       distinctiveIdentifierRequired: false,
  2221.       persistentStateRequired: false,
  2222.       videoRobustness: '',
  2223.       audioRobustness: '',
  2224.       serverCertificate: new Uint8Array(0)
  2225.     }
  2226.   };
  2227. };
  2230. /**
  2231.  * @return {shakaExtern.PlayerConfiguration}
  2232.  * @private
  2233.  */
  2234. shaka.Player.prototype.defaultConfig_ = function() {
  2235.   // This is a relatively safe default, since 3G cell connections
  2236.   // are faster than this.  For slower connections, such as 2G,
  2237.   // the default estimate may be too high.
  2238.   let bandwidthEstimate = 500e3; // 500kbps
  2240.   let abrMaxHeight = Infinity;
  2242.   // Some browsers implement the Network Information API, which allows
  2243.   // retrieving information about a user's network connection.
  2244.   //
  2245.   // We are excluding connection.type == undefined to avoid getting bogus data
  2246.   // on platforms where the implementation is incomplete.  Currently, desktop
  2247.   // Chrome 64 returns connection type undefined and a bogus downlink value.
  2248.   if (navigator.connection && navigator.connection.type) {
  2249.     // If it's available, get the bandwidth estimate from the browser (in
  2250.     // megabits per second) and use it as defaultBandwidthEstimate.
  2251.     bandwidthEstimate = navigator.connection.downlink * 1e6;
  2252.     // TODO: Move this into AbrManager, where changes to the estimate can be
  2253.     // observed and absorbed.
  2255.     // If the user has checked a box in the browser to ask it to use less data,
  2256.     // the browser will expose this intent via connection.saveData.  When that
  2257.     // is true, we will default the max ABR height to 360p.  Apps can override
  2258.     // this if they wish.
  2259.     //
  2260.     // The decision to use 360p was somewhat arbitrary.  We needed a default
  2261.     // limit, and rather than restrict to a certain bandwidth, we decided to
  2262.     // restrict resolution.  This will implicitly restrict bandwidth and
  2263.     // therefore save data.  We (Shaka+Chrome) judged that:
  2264.     //   - HD would be inappropriate
  2265.     //   - If a user is asking their browser to save data, 360p it reasonable
  2266.     //   - 360p would not look terrible on small mobile device screen
  2267.     // We also found that:
  2268.     //   - YouTube's website on mobile defaults to 360p (as of 2018)
  2269.     //   - iPhone 6, in portrait mode, has a physical resolution big enough
  2270.     //     for 360p widescreen, but a little smaller than 480p widescreen
  2271.     //     (https://goo.gl/5trzW5)
  2272.     // If the content's lowest resolution is above 360p, AbrManager will use
  2273.     // the lowest resolution.
  2274.     if (navigator.connection.saveData) {
  2275.       abrMaxHeight = 360;
  2276.     }
  2277.   }
  2279.   // Because this.video_ may not be set when the config is built, the default
  2280.   // TextDisplay factory must capture a reference to "this" as "self" to use at
  2281.   // the time we call the factory.  Bind can't be used here because we call the
  2282.   // factory with "new", effectively removing any binding to "this".
  2283.   const self = this;
  2284.   const defaultTextDisplayFactory = function() {
  2285.     return new shaka.text.SimpleTextDisplayer(self.video_);
  2286.   };
  2288.   return {
  2289.     drm: {
  2290.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  2291.       // These will all be verified by special cases in mergeConfigObjects_():
  2292.       servers: {},    // key is arbitrary key system ID, value must be string
  2293.       clearKeys: {},  // key is arbitrary key system ID, value must be string
  2294.       advanced: {},    // key is arbitrary key system ID, value is a record type
  2295.       delayLicenseRequestUntilPlayed: false
  2296.     },
  2297.     manifest: {
  2298.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  2299.       availabilityWindowOverride: NaN,
  2300.       dash: {
  2301.         customScheme: function(node) {
  2302.           // Reference node to keep closure from removing it.
  2303.           // If the argument is removed, it breaks our function length check
  2304.           // in mergeConfigObjects_().
  2305.           // TODO: Find a better solution if possible.
  2306.           // NOTE: Chrome App Content Security Policy prohibits usage of new
  2307.           // Function()
  2309.           if (node) return null;
  2310.         },
  2311.         clockSyncUri: '',
  2312.         ignoreDrmInfo: false,
  2313.         xlinkFailGracefully: false,
  2314.         defaultPresentationDelay: 10
  2315.       }
  2316.     },
  2317.     streaming: {
  2318.       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
  2319.       failureCallback:
  2320.           this.defaultStreamingFailureCallback_.bind(this),
  2321.       rebufferingGoal: 2,
  2322.       bufferingGoal: 10,
  2323.       bufferBehind: 30,
  2324.       ignoreTextStreamFailures: false,
  2325.       alwaysStreamText: false,
  2326.       startAtSegmentBoundary: false,
  2327.       smallGapLimit: 0.5,
  2328.       jumpLargeGaps: false,
  2329.       durationBackoff: 1,
  2330.       forceTransmuxTS: false
  2331.     },
  2332.     abrFactory: shaka.abr.SimpleAbrManager,
  2333.     textDisplayFactory: defaultTextDisplayFactory,
  2334.     abr: {
  2335.       enabled: true,
  2336.       defaultBandwidthEstimate: bandwidthEstimate,
  2337.       switchInterval: 8,
  2338.       bandwidthUpgradeTarget: 0.85,
  2339.       bandwidthDowngradeTarget: 0.95,
  2340.       restrictions: {
  2341.         minWidth: 0,
  2342.         maxWidth: Infinity,
  2343.         minHeight: 0,
  2344.         maxHeight: abrMaxHeight,
  2345.         minPixels: 0,
  2346.         maxPixels: Infinity,
  2347.         minBandwidth: 0,
  2348.         maxBandwidth: Infinity
  2349.       }
  2350.     },
  2351.     preferredAudioLanguage: '',
  2352.     preferredTextLanguage: '',
  2353.     preferredVariantRole: '',
  2354.     preferredTextRole: '',
  2355.     preferredAudioChannelCount: 2,
  2356.     restrictions: {
  2357.       minWidth: 0,
  2358.       maxWidth: Infinity,
  2359.       minHeight: 0,
  2360.       maxHeight: Infinity,
  2361.       minPixels: 0,
  2362.       maxPixels: Infinity,
  2363.       minBandwidth: 0,
  2364.       maxBandwidth: Infinity
  2365.     },
  2366.     playRangeStart: 0,
  2367.     playRangeEnd: Infinity
  2368.   };
  2369. };
  2372. /**
  2373.  * @param {!shaka.util.Error} error
  2374.  * @private
  2375.  */
  2376. shaka.Player.prototype.defaultStreamingFailureCallback_ = function(error) {
  2377.   let retryErrorCodes = [
  2378.     shaka.util.Error.Code.BAD_HTTP_STATUS,
  2379.     shaka.util.Error.Code.HTTP_ERROR,
  2380.     shaka.util.Error.Code.TIMEOUT
  2381.   ];
  2383.   if (this.isLive() && retryErrorCodes.indexOf(error.code) >= 0) {
  2384.     error.severity = shaka.util.Error.Severity.RECOVERABLE;
  2386.     shaka.log.warning('Live streaming error.  Retrying automatically...');
  2387.     this.retryStreaming();
  2388.   }
  2389. };
  2392. /**
  2393.  * @return {shakaExtern.Stats}
  2394.  * @private
  2395.  */
  2396. shaka.Player.prototype.getCleanStats_ = function() {
  2397.   return {
  2398.     // These are not tracked in the private stats structure and are only here to
  2399.     // satisfy the compiler.
  2400.     width: NaN,
  2401.     height: NaN,
  2402.     streamBandwidth: NaN,
  2403.     decodedFrames: NaN,
  2404.     droppedFrames: NaN,
  2405.     estimatedBandwidth: NaN,
  2407.     // These are tracked in the private stats structure to avoid the need for
  2408.     // many private member variables.
  2409.     loadLatency: NaN,
  2410.     playTime: 0,
  2411.     bufferingTime: 0,
  2412.     switchHistory: [],
  2413.     stateHistory: []
  2414.   };
  2415. };
  2418. /**
  2419.  * Filters a list of periods.
  2420.  * @param {!Array.<!shakaExtern.Period>} periods
  2421.  * @private
  2422.  */
  2423. shaka.Player.prototype.filterAllPeriods_ = function(periods) {
  2424.   goog.asserts.assert(this.video_, 'Must not be destroyed');
  2425.   const ArrayUtils = shaka.util.ArrayUtils;
  2426.   const StreamUtils = shaka.util.StreamUtils;
  2428.   /** @type {?shakaExtern.Stream} */
  2429.   let activeAudio =
  2430.       this.streamingEngine_ ? this.streamingEngine_.getActiveAudio() : null;
  2431.   /** @type {?shakaExtern.Stream} */
  2432.   let activeVideo =
  2433.       this.streamingEngine_ ? this.streamingEngine_.getActiveVideo() : null;
  2435.   let filterPeriod = StreamUtils.filterNewPeriod.bind(
  2436.       null, this.drmEngine_, activeAudio, activeVideo);
  2437.   periods.forEach(filterPeriod);
  2439.   let validPeriodsCount = ArrayUtils.count(periods, function(period) {
  2440.     return period.variants.some(StreamUtils.isPlayable);
  2441.   });
  2443.   // If none of the periods are playable, throw CONTENT_UNSUPPORTED_BY_BROWSER.
  2444.   if (validPeriodsCount == 0) {
  2445.     throw new shaka.util.Error(
  2446.         shaka.util.Error.Severity.CRITICAL,
  2447.         shaka.util.Error.Category.MANIFEST,
  2448.         shaka.util.Error.Code.CONTENT_UNSUPPORTED_BY_BROWSER);
  2449.   }
  2451.   // If only some of the periods are playable, throw UNPLAYABLE_PERIOD.
  2452.   if (validPeriodsCount < periods.length) {
  2453.     throw new shaka.util.Error(
  2454.         shaka.util.Error.Severity.CRITICAL,
  2455.         shaka.util.Error.Category.MANIFEST,
  2456.         shaka.util.Error.Code.UNPLAYABLE_PERIOD);
  2457.   }
  2459.   periods.forEach(function(period) {
  2460.     let tracksChanged = shaka.util.StreamUtils.applyRestrictions(
  2461.         period, this.config_.restrictions, this.maxHwRes_);
  2462.     if (tracksChanged && this.streamingEngine_ &&
  2463.         this.streamingEngine_.getCurrentPeriod() == period) {
  2464.       this.onTracksChanged_();
  2465.     }
  2467.     let hasValidVariant = period.variants.some(StreamUtils.isPlayable);
  2468.     if (!hasValidVariant) {
  2469.       throw new shaka.util.Error(
  2470.           shaka.util.Error.Severity.CRITICAL,
  2471.           shaka.util.Error.Category.MANIFEST,
  2472.           shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET);
  2473.     }
  2474.   }.bind(this));
  2475. };
  2478. /**
  2479.  * Filters a new period.
  2480.  * @param {shakaExtern.Period} period
  2481.  * @private
  2482.  */
  2483. shaka.Player.prototype.filterNewPeriod_ = function(period) {
  2484.   goog.asserts.assert(this.video_, 'Must not be destroyed');
  2485.   const StreamUtils = shaka.util.StreamUtils;
  2487.   /** @type {?shakaExtern.Stream} */
  2488.   let activeAudio =
  2489.       this.streamingEngine_ ? this.streamingEngine_.getActiveAudio() : null;
  2490.   /** @type {?shakaExtern.Stream} */
  2491.   let activeVideo =
  2492.       this.streamingEngine_ ? this.streamingEngine_.getActiveVideo() : null;
  2494.   StreamUtils.filterNewPeriod(
  2495.       this.drmEngine_, activeAudio, activeVideo, period);
  2497.   /** @type {!Array.<shakaExtern.Variant>} */
  2498.   let variants = period.variants;
  2500.   // Check for playable variants before restrictions, so that we can give a
  2501.   // special error when there were tracks but they were all filtered.
  2502.   let hasPlayableVariant = variants.some(StreamUtils.isPlayable);
  2504.   let tracksChanged = shaka.util.StreamUtils.applyRestrictions(
  2505.       period, this.config_.restrictions, this.maxHwRes_);
  2506.   if (tracksChanged && this.streamingEngine_ &&
  2507.       this.streamingEngine_.getCurrentPeriod() == period) {
  2508.     this.onTracksChanged_();
  2509.   }
  2511.   // Check for playable variants again.  If the first check found variants, but
  2512.   // not the second, then all variants are restricted.
  2513.   let hasAvailableVariant = variants.some(StreamUtils.isPlayable);
  2515.   if (!hasPlayableVariant) {
  2516.     throw new shaka.util.Error(
  2517.         shaka.util.Error.Severity.CRITICAL,
  2518.         shaka.util.Error.Category.MANIFEST,
  2519.         shaka.util.Error.Code.UNPLAYABLE_PERIOD);
  2520.   }
  2522.   if (!hasAvailableVariant) {
  2523.     throw new shaka.util.Error(
  2524.         shaka.util.Error.Severity.CRITICAL,
  2525.         shaka.util.Error.Category.MANIFEST,
  2526.         shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET);
  2527.   }
  2529.   // For new Periods, we may need to create new sessions for any new init data.
  2530.   const curDrmInfo = this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  2531.   if (curDrmInfo) {
  2532.     for (const variant of variants) {
  2533.       for (const drmInfo of variant.drmInfos) {
  2534.         // Ignore any data for different key systems.
  2535.         if (drmInfo.keySystem == curDrmInfo.keySystem) {
  2536.           for (const initData of (drmInfo.initData || [])) {
  2537.             this.drmEngine_.newInitData(
  2538.                 initData.initDataType, initData.initData);
  2539.           }
  2540.         }
  2541.       }
  2542.     }
  2543.   }
  2544. };
  2547. /**
  2548.  * Switches to the given variant, deferring if needed.
  2549.  * @param {shakaExtern.Variant} variant
  2550.  * @param {boolean=} opt_clearBuffer
  2551.  * @private
  2552.  */
  2553. shaka.Player.prototype.switchVariant_ =
  2554.     function(variant, opt_clearBuffer) {
  2555.   if (this.switchingPeriods_) {
  2556.     // Store this action for later.
  2557.     this.deferredVariant_ = variant;
  2558.     this.deferredVariantClearBuffer_ = opt_clearBuffer || false;
  2559.   } else {
  2560.     // Act now.
  2561.     this.streamingEngine_.switchVariant(variant, opt_clearBuffer || false);
  2562.   }
  2563. };
  2566. /**
  2567.  * Switches to the given text stream, deferring if needed.
  2568.  * @param {shakaExtern.Stream} textStream
  2569.  * @private
  2570.  */
  2571. shaka.Player.prototype.switchTextStream_ = function(textStream) {
  2572.   if (this.switchingPeriods_) {
  2573.     // Store this action for later.
  2574.     this.deferredTextStream_ = textStream;
  2575.   } else {
  2576.     // Act now.
  2577.     this.streamingEngine_.switchTextStream(textStream);
  2578.   }
  2579. };
  2582. /**
  2583.  * Verifies that the active streams according to the player match those in
  2584.  * StreamingEngine.
  2585.  * @private
  2586.  */
  2587. shaka.Player.prototype.assertCorrectActiveStreams_ = function() {
  2588.   if (!this.streamingEngine_ || !this.manifest_ || !goog.DEBUG) return;
  2589.   const StreamUtils = shaka.util.StreamUtils;
  2590.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2592.   let activeAudio = this.streamingEngine_.getActiveAudio();
  2593.   let activeVideo = this.streamingEngine_.getActiveVideo();
  2594.   let activeText = this.streamingEngine_.getActiveText();
  2596.   /** @type {?shakaExtern.Stream} */
  2597.   let mainStream = activeVideo || activeAudio;
  2598.   if (!mainStream) {
  2599.     return;
  2600.   }
  2602.   let streamingPeriodIndex =
  2603.       StreamUtils.findPeriodContainingStream(this.manifest_, mainStream);
  2604.   let currentPeriodIndex =
  2605.       this.manifest_.periods.indexOf(this.streamingEngine_.getCurrentPeriod());
  2606.   if (streamingPeriodIndex < 0 || streamingPeriodIndex != currentPeriodIndex) {
  2607.     return;
  2608.   }
  2610.   let playerActive = this.activeStreamsByPeriod_[currentPeriodIndex] || {};
  2611.   let activeStreams = [activeAudio, activeVideo, activeText];
  2612.   activeStreams.forEach(function(stream) {
  2613.     if (stream) {
  2614.       let id = stream.id;
  2615.       let type = stream.type;
  2617.       if (type == ContentType.TEXT && this.deferredTextStream_) {
  2618.         id = this.deferredTextStream_.id;
  2619.       }
  2621.       if (type == ContentType.AUDIO && this.deferredVariant_) {
  2622.         id = this.deferredVariant_.audio.id;
  2623.       }
  2625.       if (type == ContentType.VIDEO && this.deferredVariant_) {
  2626.         id = this.deferredVariant_.video.id;
  2627.       }
  2629.       goog.asserts.assert(
  2630.           id == playerActive[type], 'Inconsistent active stream');
  2631.     }
  2632.   }.bind(this));
  2633. };
  2636. /** @private */
  2637. shaka.Player.prototype.updateTimeStats_ = function() {
  2638.   // Only count while we're loaded.
  2639.   if (!this.manifest_) {
  2640.     return;
  2641.   }
  2643.   let now = Date.now() / 1000;
  2644.   if (this.buffering_) {
  2645.     this.stats_.bufferingTime += (now - this.lastTimeStatsUpdateTimestamp_);
  2646.   } else {
  2647.     this.stats_.playTime += (now - this.lastTimeStatsUpdateTimestamp_);
  2648.   }
  2650.   this.lastTimeStatsUpdateTimestamp_ = now;
  2651. };
  2654. /**
  2655.  * @param {number} time
  2656.  * @return {number}
  2657.  * @private
  2658.  */
  2659. shaka.Player.prototype.adjustStartTime_ = function(time) {
  2660.   /** @type {?shakaExtern.Stream} */
  2661.   let activeAudio = this.streamingEngine_.getActiveAudio();
  2662.   /** @type {?shakaExtern.Stream} */
  2663.   let activeVideo = this.streamingEngine_.getActiveVideo();
  2664.   /** @type {shakaExtern.Period} */
  2665.   let period = this.streamingEngine_.getCurrentPeriod();
  2667.   // This method is called after StreamingEngine.init resolves, which means that
  2668.   // all the active streams have had createSegmentIndex called.
  2669.   function getAdjustedTime(stream, time) {
  2670.     if (!stream) return null;
  2671.     let idx = stream.findSegmentPosition(time - period.startTime);
  2672.     if (idx == null) return null;
  2673.     let ref = stream.getSegmentReference(idx);
  2674.     if (!ref) return null;
  2675.     let refTime = ref.startTime + period.startTime;
  2676.     goog.asserts.assert(refTime <= time, 'Segment should start before time');
  2677.     return refTime;
  2678.   }
  2680.   let audioStartTime = getAdjustedTime(activeAudio, time);
  2681.   let videoStartTime = getAdjustedTime(activeVideo, time);
  2683.   // If we have both video and audio times, pick the larger one.  If we picked
  2684.   // the smaller one, that one will download an entire segment to buffer the
  2685.   // difference.
  2686.   if (videoStartTime != null && audioStartTime != null) {
  2687.     return Math.max(videoStartTime, audioStartTime);
  2688.   } else if (videoStartTime != null) {
  2689.     return videoStartTime;
  2690.   } else if (audioStartTime != null) {
  2691.     return audioStartTime;
  2692.   } else {
  2693.     return time;
  2694.   }
  2695. };
  2698. /**
  2699.  * Callback from NetworkingEngine.
  2700.  *
  2701.  * @param {number} deltaTimeMs
  2702.  * @param {number} numBytes
  2703.  * @private
  2704.  */
  2705. shaka.Player.prototype.onSegmentDownloaded_ = function(deltaTimeMs, numBytes) {
  2706.   if (this.abrManager_) {
  2707.     // Abr manager might not exist during offline storage.
  2708.     this.abrManager_.segmentDownloaded(deltaTimeMs, numBytes);
  2709.   }
  2710. };
  2713. /**
  2714.  * Callback from PlayheadObserver.
  2715.  *
  2716.  * @param {boolean} buffering
  2717.  * @private
  2718.  */
  2719. shaka.Player.prototype.onBuffering_ = function(buffering) {
  2720.   // Before setting |buffering_|, update the time spent in the previous state.
  2721.   this.updateTimeStats_();
  2722.   this.buffering_ = buffering;
  2723.   this.updateState_();
  2725.   if (this.playhead_) {
  2726.     this.playhead_.setBuffering(buffering);
  2727.   }
  2729.   let event = new shaka.util.FakeEvent('buffering', {'buffering': buffering});
  2730.   this.dispatchEvent(event);
  2731. };
  2734. /**
  2735.  * Callback from PlayheadObserver.
  2736.  * @private
  2737.  */
  2738. shaka.Player.prototype.onChangePeriod_ = function() {
  2739.   this.onTracksChanged_();
  2740. };
  2743. /**
  2744.  * Called from potential initiators of state changes, or before returning stats
  2745.  * to the user.
  2746.  *
  2747.  * This method decides if state has actually changed, updates the last entry,
  2748.  * and adds a new one if needed.
  2749.  *
  2750.  * @private
  2751.  */
  2752. shaka.Player.prototype.updateState_ = function() {
  2753.   if (this.destroyed_) return;
  2755.   let newState;
  2756.   if (this.buffering_) {
  2757.     newState = 'buffering';
  2758.   } else if (this.video_.ended) {
  2759.     newState = 'ended';
  2760.   } else if (this.video_.paused) {
  2761.     newState = 'paused';
  2762.   } else {
  2763.     newState = 'playing';
  2764.   }
  2766.   let now = Date.now() / 1000;
  2767.   if (this.stats_.stateHistory.length) {
  2768.     let lastIndex = this.stats_.stateHistory.length - 1;
  2769.     let lastEntry = this.stats_.stateHistory[lastIndex];
  2770.     lastEntry.duration = now - lastEntry.timestamp;
  2772.     if (newState == lastEntry.state) {
  2773.       // The state has not changed, so do not add anything to the history.
  2774.       return;
  2775.     }
  2776.   }
  2778.   this.stats_.stateHistory.push({
  2779.     timestamp: now,
  2780.     state: newState,
  2781.     duration: 0
  2782.   });
  2783. };
  2786. /**
  2787.  * Callback from Playhead.
  2788.  *
  2789.  * @private
  2790.  */
  2791. shaka.Player.prototype.onSeek_ = function() {
  2792.   if (this.playheadObserver_) {
  2793.     this.playheadObserver_.seeked();
  2794.   }
  2795.   if (this.streamingEngine_) {
  2796.     this.streamingEngine_.seeked();
  2797.   }
  2798. };
  2801. /**
  2802.  * Chooses a variant through the ABR manager.
  2803.  * On error, this dispatches an error event and returns null.
  2804.  *
  2805.  * @param {!Array.<shakaExtern.Variant>} variants
  2806.  * @return {?shakaExtern.Variant}
  2807.  * @private
  2808.  */
  2809. shaka.Player.prototype.chooseVariant_ = function(variants) {
  2810.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  2812.   if (!variants || !variants.length) {
  2813.     this.onError_(new shaka.util.Error(
  2814.         shaka.util.Error.Severity.CRITICAL,
  2815.         shaka.util.Error.Category.MANIFEST,
  2816.         shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET));
  2817.     return null;
  2818.   }
  2820.   // Update the abr manager with newly filtered variants.
  2821.   this.abrManager_.setVariants(variants);
  2822.   return this.abrManager_.chooseVariant();
  2823. };
  2826. /**
  2827.  * Chooses streams from the given Period and switches to them.
  2828.  * Called after a config change, a new text stream, a key status event, or an
  2829.  * explicit language change.
  2830.  *
  2831.  * @param {!shakaExtern.Period} period
  2832.  * @private
  2833.  */
  2834. shaka.Player.prototype.chooseStreamsAndSwitch_ = function(period) {
  2835.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  2837.   let variants = shaka.util.StreamUtils.filterVariantsByConfig(
  2838.       period.variants, this.currentAudioLanguage_, this.currentVariantRole_,
  2839.       this.currentAudioChannelCount_);
  2840.   let textStreams = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  2841.       period.textStreams, this.currentTextLanguage_, this.currentTextRole_);
  2843.   // Because we're running this after a config change (manual language change),
  2844.   // a new text stream, or a key status event, and because switching to an
  2845.   // active stream is a no-op, it is always okay to clear the buffer here.
  2846.   let chosenVariant = this.chooseVariant_(variants);
  2847.   if (chosenVariant) {
  2848.     this.addVariantToSwitchHistory_(chosenVariant, /* fromAdaptation */ true);
  2849.     this.switchVariant_(chosenVariant, true);
  2850.   }
  2852.   // Only switch text if we should be streaming text right now.
  2853.   let chosenText = textStreams[0];
  2854.   if (chosenText && this.streamText_()) {
  2855.     this.addTextStreamToSwitchHistory_(chosenText, /* fromAdaptation */ true);
  2856.     this.switchTextStream_(chosenText);
  2857.   }
  2859.   // Send an adaptation event so that the UI can show the new language/tracks.
  2860.   this.onAdaptation_();
  2861. };
  2864. /**
  2865.  * Callback from StreamingEngine, invoked when a period starts.
  2866.  *
  2867.  * @param {!shakaExtern.Period} period
  2868.  * @return {shaka.media.StreamingEngine.ChosenStreams} An object containing the
  2869.  *   chosen variant and text stream.
  2870.  * @private
  2871.  */
  2872. shaka.Player.prototype.onChooseStreams_ = function(period) {
  2873.   shaka.log.debug('onChooseStreams_', period);
  2874.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  2876.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2877.   const StreamUtils = shaka.util.StreamUtils;
  2879.   // We are switching Periods, so the AbrManager will be disabled.  But if we
  2880.   // want to abr.enabled, we do not want to call AbrManager.enable before
  2881.   // canSwitch_ is called.
  2882.   this.switchingPeriods_ = true;
  2883.   this.abrManager_.disable();
  2885.   shaka.log.debug('Choosing new streams after period changed');
  2887.   // Create empty object first and initialize the fields through
  2888.   // [] to allow field names to be expressions.
  2889.   // TODO: This feedback system for language matches could be cleaned up.
  2890.   let languageMatches = {};
  2891.   languageMatches[ContentType.AUDIO] = false;
  2892.   languageMatches[ContentType.TEXT] = false;
  2894.   let variants = StreamUtils.filterVariantsByConfig(
  2895.       period.variants,
  2896.       this.currentAudioLanguage_,
  2897.       this.currentVariantRole_,
  2898.       this.currentAudioChannelCount_,
  2899.       languageMatches);
  2901.   let textStreams = StreamUtils.filterStreamsByLanguageAndRole(
  2902.       period.textStreams, this.currentTextLanguage_, this.currentTextRole_,
  2903.       languageMatches);
  2905.   shaka.log.v2('onChooseStreams_, variants and text streams: ',
  2906.                variants, textStreams);
  2908.   let chosenVariant = this.chooseVariant_(variants);
  2909.   let chosenTextStream = textStreams[0] || null;
  2911.   shaka.log.v2('onChooseStreams_, chosen=', chosenVariant, chosenTextStream);
  2913.   // This assertion satisfies a compiler nullability check below.
  2914.   goog.asserts.assert(this.manifest_, 'Manifest should exist!');
  2916.   // Ignore deferred variant or text streams only if we are starting a new
  2917.   // period.  In this case, any deferred switches were from an older period, so
  2918.   // they do not apply.  We can still have deferred switches from the current
  2919.   // period in the case of an early call to select*Track while we are setting up
  2920.   // the first period.  This can happen with the 'streaming' event.
  2921.   if (this.deferredVariant_) {
  2922.     const deferredPeriodIndex = StreamUtils.findPeriodContainingVariant(
  2923.         this.manifest_, this.deferredVariant_);
  2924.     const deferredPeriod = this.manifest_.periods[deferredPeriodIndex];
  2925.     if (deferredPeriod == period) {
  2926.       chosenVariant = this.deferredVariant_;
  2927.     }
  2928.     this.deferredVariant_ = null;
  2929.   }
  2930.   if (this.deferredTextStream_) {
  2931.     const deferredPeriodIndex = StreamUtils.findPeriodContainingStream(
  2932.         this.manifest_, this.deferredTextStream_);
  2933.     const deferredPeriod = this.manifest_.periods[deferredPeriodIndex];
  2934.     if (deferredPeriod == period) {
  2935.       chosenTextStream = this.deferredTextStream_;
  2936.     }
  2937.     this.deferredTextStream_ = null;
  2938.   }
  2940.   if (chosenVariant) {
  2941.     this.addVariantToSwitchHistory_(chosenVariant, /* fromAdaptation */ true);
  2942.   }
  2943.   if (chosenTextStream) {
  2944.     this.addTextStreamToSwitchHistory_(
  2945.         chosenTextStream, /* fromAdaptation */ true);
  2947.     // If audio and text tracks have different languages, and the text track
  2948.     // matches the user's preference, then show the captions.  Only do this
  2949.     // when we are choosing the initial tracks during startup.
  2950.     let startingUp = !this.streamingEngine_.getActivePeriod();
  2951.     if (startingUp) {
  2952.       if (chosenVariant && chosenVariant.audio &&
  2953.           languageMatches[ContentType.TEXT] &&
  2954.           chosenTextStream.language != chosenVariant.audio.language) {
  2955.         this.textDisplayer_.setTextVisibility(true);
  2956.         this.onTextTrackVisibility_();
  2957.       }
  2958.     }
  2959.   }
  2961.   // Don't fire a tracks-changed event since we aren't inside the new Period
  2962.   // yet.
  2963.   // Don't initialize with a text stream unless we should be streaming text.
  2964.   if (this.streamText_()) {
  2965.     return {variant: chosenVariant, text: chosenTextStream};
  2966.   } else {
  2967.     return {variant: chosenVariant, text: null};
  2968.   }
  2969. };
  2972. /**
  2973.  * Callback from StreamingEngine, invoked when the period is set up.
  2974.  *
  2975.  * @private
  2976.  */
  2977. shaka.Player.prototype.canSwitch_ = function() {
  2978.   shaka.log.debug('canSwitch_');
  2979.   goog.asserts.assert(this.config_, 'Must not be destroyed');
  2981.   this.switchingPeriods_ = false;
  2983.   if (this.config_.abr.enabled) {
  2984.     this.abrManager_.enable();
  2985.   }
  2987.   // If we still have deferred switches, switch now.
  2988.   if (this.deferredVariant_) {
  2989.     this.streamingEngine_.switchVariant(
  2990.         this.deferredVariant_, this.deferredVariantClearBuffer_);
  2991.     this.deferredVariant_ = null;
  2992.   }
  2993.   if (this.deferredTextStream_) {
  2994.     this.streamingEngine_.switchTextStream(this.deferredTextStream_);
  2995.     this.deferredTextStream_ = null;
  2996.   }
  2997. };
  3000. /**
  3001.  * Callback from StreamingEngine.
  3002.  *
  3003.  * @private
  3004.  */
  3005. shaka.Player.prototype.onManifestUpdate_ = function() {
  3006.   if (this.parser_ && this.parser_.update) {
  3007.     this.parser_.update();
  3008.   }
  3009. };
  3012. /**
  3013.  * Callback from StreamingEngine.
  3014.  *
  3015.  * @private
  3016.  */
  3017. shaka.Player.prototype.onSegmentAppended_ = function() {
  3018.   if (this.playhead_) {
  3019.     this.playhead_.onSegmentAppended();
  3020.   }
  3021. };
  3024. /**
  3025.  * Callback from AbrManager.
  3026.  *
  3027.  * @param {shakaExtern.Variant} variant
  3028.  * @param {boolean=} opt_clearBuffer
  3029.  * @private
  3030.  */
  3031. shaka.Player.prototype.switch_ = function(variant, opt_clearBuffer) {
  3032.   shaka.log.debug('switch_');
  3033.   goog.asserts.assert(this.config_.abr.enabled,
  3034.       'AbrManager should not call switch while disabled!');
  3035.   goog.asserts.assert(!this.switchingPeriods_,
  3036.       'AbrManager should not call switch while transitioning between Periods!');
  3038.   this.addVariantToSwitchHistory_(variant, /* fromAdaptation */ true);
  3040.   if (!this.streamingEngine_) {
  3041.     // There's no way to change it.
  3042.     return;
  3043.   }
  3045.   this.streamingEngine_.switchVariant(variant, opt_clearBuffer || false);
  3046.   this.onAdaptation_();
  3047. };
  3050. /**
  3051.  * Dispatches an 'adaptation' event.
  3052.  * @private
  3053.  */
  3054. shaka.Player.prototype.onAdaptation_ = function() {
  3055.   // In the next frame, dispatch an 'adaptation' event.
  3056.   // This gives StreamingEngine time to absorb the changes before the user
  3057.   // tries to query them.
  3058.   Promise.resolve().then(function() {
  3059.     if (this.destroyed_) return;
  3060.     let event = new shaka.util.FakeEvent('adaptation');
  3061.     this.dispatchEvent(event);
  3062.   }.bind(this));
  3063. };
  3066. /**
  3067.  * Dispatches a 'trackschanged' event.
  3068.  * @private
  3069.  */
  3070. shaka.Player.prototype.onTracksChanged_ = function() {
  3071.   // In the next frame, dispatch a 'trackschanged' event.
  3072.   // This gives StreamingEngine time to absorb the changes before the user
  3073.   // tries to query them.
  3074.   Promise.resolve().then(function() {
  3075.     if (this.destroyed_) return;
  3076.     let event = new shaka.util.FakeEvent('trackschanged');
  3077.     this.dispatchEvent(event);
  3078.   }.bind(this));
  3079. };
  3082. /** @private */
  3083. shaka.Player.prototype.onTextTrackVisibility_ = function() {
  3084.   let event = new shaka.util.FakeEvent('texttrackvisibility');
  3085.   this.dispatchEvent(event);
  3086. };
  3089. /**
  3090.  * @param {!shaka.util.Error} error
  3091.  * @private
  3092.  */
  3093. shaka.Player.prototype.onError_ = function(error) {
  3094.   // Errors dispatched after destroy is called are irrelevant.
  3095.   if (this.destroyed_) return;
  3097.   goog.asserts.assert(error instanceof shaka.util.Error, 'Wrong error type!');
  3099.   let event = new shaka.util.FakeEvent('error', {'detail': error});
  3100.   this.dispatchEvent(event);
  3101.   if (event.defaultPrevented) {
  3102.     error.handled = true;
  3103.   }
  3104. };
  3107. /**
  3108.  * @param {shakaExtern.TimelineRegionInfo} region
  3109.  * @private
  3110.  */
  3111. shaka.Player.prototype.onTimelineRegionAdded_ = function(region) {
  3112.   if (this.playheadObserver_) {
  3113.     this.playheadObserver_.addTimelineRegion(region);
  3114.   } else {
  3115.     this.pendingTimelineRegions_.push(region);
  3116.   }
  3117. };
  3120. /**
  3121.  * @param {!Event} event
  3122.  * @private
  3123.  */
  3124. shaka.Player.prototype.onEvent_ = function(event) {
  3125.   this.dispatchEvent(event);
  3126. };
  3129. /**
  3130.  * @param {!Event} event
  3131.  * @private
  3132.  */
  3133. shaka.Player.prototype.onVideoError_ = function(event) {
  3134.   if (!this.video_.error) return;
  3136.   let code = this.video_.error.code;
  3137.   if (code == 1 /* MEDIA_ERR_ABORTED */) {
  3138.     // Ignore this error code, which should only occur when navigating away or
  3139.     // deliberately stopping playback of HTTP content.
  3140.     return;
  3141.   }
  3143.   // Extra error information from MS Edge and IE11:
  3144.   let extended = this.video_.error.msExtendedCode;
  3145.   if (extended) {
  3146.     // Convert to unsigned:
  3147.     if (extended < 0) {
  3148.       extended += Math.pow(2, 32);
  3149.     }
  3150.     // Format as hex:
  3151.     extended = extended.toString(16);
  3152.   }
  3154.   // Extra error information from Chrome:
  3155.   let message = this.video_.error.message;
  3157.   this.onError_(new shaka.util.Error(
  3158.       shaka.util.Error.Severity.CRITICAL,
  3159.       shaka.util.Error.Category.MEDIA,
  3160.       shaka.util.Error.Code.VIDEO_ERROR,
  3161.       code, extended, message));
  3162. };
  3165. /**
  3166.  * @param {!Object.<string, string>} keyStatusMap A map of hex key IDs to
  3167.  *   statuses.
  3168.  * @private
  3169.  */
  3170. shaka.Player.prototype.onKeyStatus_ = function(keyStatusMap) {
  3171.   goog.asserts.assert(this.streamingEngine_, 'Should have been initialized.');
  3172.   // 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
  3173.   // of the usable keys.
  3174.   // 'expired' status is being handled separately in DrmEngine.
  3175.   let restrictedStatuses = ['output-restricted', 'internal-error'];
  3177.   let period = this.streamingEngine_.getCurrentPeriod();
  3178.   let tracksChanged = false;
  3180.   let keyIds = Object.keys(keyStatusMap);
  3181.   if (keyIds.length == 0) {
  3182.     shaka.log.warning(
  3183.         'Got a key status event without any key statuses, so we don\'t know ' +
  3184.         'the real key statuses. If we don\'t have all the keys, you\'ll need ' +
  3185.         'to set restrictions so we don\'t select those tracks.');
  3186.   }
  3188.   // If EME is using a synthetic key ID, the only key ID is '00' (a single 0
  3189.   // byte).  In this case, it is only used to report global success/failure.
  3190.   // See note about old platforms in: https://goo.gl/KtQMja
  3191.   let isGlobalStatus = keyIds.length == 1 && keyIds[0] == '00';
  3193.   if (isGlobalStatus) {
  3194.     shaka.log.warning(
  3195.         'Got a synthetic key status event, so we don\'t know the real key ' +
  3196.         'statuses. If we don\'t have all the keys, you\'ll need to set ' +
  3197.         'restrictions so we don\'t select those tracks.');
  3198.   }
  3200.   // Only filter tracks for keys if we have some key statuses to look at.
  3201.   if (keyIds.length) {
  3202.     period.variants.forEach(function(variant) {
  3203.       let streams = [];
  3204.       if (variant.audio) streams.push(variant.audio);
  3205.       if (variant.video) streams.push(variant.video);
  3207.       streams.forEach(function(stream) {
  3208.         let originalAllowed = variant.allowedByKeySystem;
  3210.         // Only update if we have a key ID for the stream.
  3211.         // If the key isn't present, then we don't have that key and the track
  3212.         // should be restricted.
  3213.         if (stream.keyId) {
  3214.           let keyStatus = keyStatusMap[isGlobalStatus ? '00' : stream.keyId];
  3215.           variant.allowedByKeySystem =
  3216.               !!keyStatus && restrictedStatuses.indexOf(keyStatus) < 0;
  3217.         }
  3219.         if (originalAllowed != variant.allowedByKeySystem) {
  3220.           tracksChanged = true;
  3221.         }
  3222.       });  // streams.forEach
  3223.     });  // period.variants.forEach
  3224.   }  // if (keyIds.length)
  3226.   // TODO: Get StreamingEngine to track variants and create getActiveVariant()
  3227.   let activeAudio = this.streamingEngine_.getActiveAudio();
  3228.   let activeVideo = this.streamingEngine_.getActiveVideo();
  3229.   let activeVariant = shaka.util.StreamUtils.getVariantByStreams(
  3230.       activeAudio, activeVideo, period.variants);
  3232.   if (activeVariant && !activeVariant.allowedByKeySystem) {
  3233.     shaka.log.debug('Choosing new streams after key status changed');
  3234.     this.chooseStreamsAndSwitch_(period);
  3235.   }
  3237.   if (tracksChanged) {
  3238.     this.onTracksChanged_();
  3240.     // Update AbrManager about any restricted/un-restricted variants.
  3241.     let variants = shaka.util.StreamUtils.filterVariantsByConfig(
  3242.         period.variants,
  3243.         this.currentAudioLanguage_,
  3244.         this.currentVariantRole_,
  3245.         this.currentAudioChannelCount_);
  3246.     this.abrManager_.setVariants(variants);
  3247.   }
  3248. };
  3251. /**
  3252.  * Callback from DrmEngine
  3253.  * @param {string} keyId
  3254.  * @param {number} expiration
  3255.  * @private
  3256.  */
  3257. shaka.Player.prototype.onExpirationUpdated_ = function(keyId, expiration) {
  3258.   if (this.parser_ && this.parser_.onExpirationUpdated) {
  3259.     this.parser_.onExpirationUpdated(keyId, expiration);
  3260.   }
  3262.   let event = new shaka.util.FakeEvent('expirationupdated');
  3263.   this.dispatchEvent(event);
  3264. };
  3266. /**
  3267.  * @return {boolean} true if we should stream text right now.
  3268.  * @private
  3269.  */
  3270. shaka.Player.prototype.streamText_ = function() {
  3271.   return this.config_.streaming.alwaysStreamText || this.isTextTrackVisible();
  3272. };