Source: lib/player.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.Player');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.config.AutoShowText');
  11. goog.require('shaka.Deprecate');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.AdaptationSetCriteria');
  14. goog.require('shaka.media.BufferingObserver');
  15. goog.require('shaka.media.DrmEngine');
  16. goog.require('shaka.media.ExampleBasedCriteria');
  17. goog.require('shaka.media.ManifestParser');
  18. goog.require('shaka.media.MediaSourceEngine');
  19. goog.require('shaka.media.MediaSourcePlayhead');
  20. goog.require('shaka.media.MetaSegmentIndex');
  21. goog.require('shaka.media.PlayRateController');
  22. goog.require('shaka.media.Playhead');
  23. goog.require('shaka.media.PlayheadObserverManager');
  24. goog.require('shaka.media.PreferenceBasedCriteria');
  25. goog.require('shaka.media.QualityObserver');
  26. goog.require('shaka.media.RegionObserver');
  27. goog.require('shaka.media.RegionTimeline');
  28. goog.require('shaka.media.SegmentIndex');
  29. goog.require('shaka.media.SegmentReference');
  30. goog.require('shaka.media.SrcEqualsPlayhead');
  31. goog.require('shaka.media.StreamingEngine');
  32. goog.require('shaka.media.TimeRangesUtils');
  33. goog.require('shaka.net.NetworkingEngine');
  34. goog.require('shaka.net.NetworkingUtils');
  35. goog.require('shaka.text.SimpleTextDisplayer');
  36. goog.require('shaka.text.StubTextDisplayer');
  37. goog.require('shaka.text.TextEngine');
  38. goog.require('shaka.text.UITextDisplayer');
  39. goog.require('shaka.text.WebVttGenerator');
  40. goog.require('shaka.util.BufferUtils');
  41. goog.require('shaka.util.CmcdManager');
  42. goog.require('shaka.util.ConfigUtils');
  43. goog.require('shaka.util.Dom');
  44. goog.require('shaka.util.Error');
  45. goog.require('shaka.util.EventManager');
  46. goog.require('shaka.util.FakeEvent');
  47. goog.require('shaka.util.FakeEventTarget');
  48. goog.require('shaka.util.IDestroyable');
  49. goog.require('shaka.util.LanguageUtils');
  50. goog.require('shaka.util.ManifestParserUtils');
  51. goog.require('shaka.util.MediaReadyState');
  52. goog.require('shaka.util.MimeUtils');
  53. goog.require('shaka.util.Mutex');
  54. goog.require('shaka.util.ObjectUtils');
  55. goog.require('shaka.util.Platform');
  56. goog.require('shaka.util.PlayerConfiguration');
  57. goog.require('shaka.util.PublicPromise');
  58. goog.require('shaka.util.Stats');
  59. goog.require('shaka.util.StreamUtils');
  60. goog.require('shaka.util.Timer');
  61. goog.require('shaka.lcevc.Dec');
  62. goog.requireType('shaka.media.PresentationTimeline');
  65. /**
  66.  * @event shaka.Player.ErrorEvent
  67.  * @description Fired when a playback error occurs.
  68.  * @property {string} type
  69.  *   'error'
  70.  * @property {!shaka.util.Error} detail
  71.  *   An object which contains details on the error.  The error's
  72.  *   <code>category</code> and <code>code</code> properties will identify the
  73.  *   specific error that occurred.  In an uncompiled build, you can also use the
  74.  *   <code>message</code> and <code>stack</code> properties to debug.
  75.  * @exportDoc
  76.  */
  78. /**
  79.  * @event shaka.Player.StateChangeEvent
  80.  * @description Fired when the player changes load states.
  81.  * @property {string} type
  82.  *    'onstatechange'
  83.  * @property {string} state
  84.  *    The name of the state that the player just entered.
  85.  * @exportDoc
  86.  */
  88. /**
  89.  * @event shaka.Player.EmsgEvent
  90.  * @description Fired when an emsg box is found in a segment.
  91.  *   If the application calls preventDefault() on this event, further parsing
  92.  *   will not happen, and no 'metadata' event will be raised for ID3 payloads.
  93.  * @property {string} type
  94.  *   'emsg'
  95.  * @property {shaka.extern.EmsgInfo} detail
  96.  *   An object which contains the content of the emsg box.
  97.  * @exportDoc
  98.  */
  101. /**
  102.  * @event shaka.Player.DownloadFailed
  103.  * @description Fired when a download has failed, for any reason.
  104.  *   'downloadfailed'
  105.  * @property {!shaka.extern.Request} request
  106.  * @property {?shaka.util.Error} error
  107.  * @param {number} httpResponseCode
  108.  * @param {boolean} aborted
  109.  * @exportDoc
  110.  */
  113. /**
  114.  * @event shaka.Player.DownloadHeadersReceived
  115.  * @description Fired when the networking engine has received the headers for
  116.  *    a download, but before the body has been downloaded.
  117.  *    If the HTTP plugin being used does not track this information, this event
  118.  *    will default to being fired when the body is received, instead.
  119.  * @property {!Object.<string, string>} headers
  120.  * @property {!shaka.extern.Request} request
  121.  * @property {!shaka.net.NetworkingEngine.RequestType} type
  122.  *   'downloadheadersreceived'
  123.  * @exportDoc
  124.  */
  127. /**
  128.  * @event shaka.Player.DrmSessionUpdateEvent
  129.  * @description Fired when the CDM has accepted the license response.
  130.  * @property {string} type
  131.  *   'drmsessionupdate'
  132.  * @exportDoc
  133.  */
  136. /**
  137.  * @event shaka.Player.TimelineRegionAddedEvent
  138.  * @description Fired when a media timeline region is added.
  139.  * @property {string} type
  140.  *   'timelineregionadded'
  141.  * @property {shaka.extern.TimelineRegionInfo} detail
  142.  *   An object which contains a description of the region.
  143.  * @exportDoc
  144.  */
  147. /**
  148.  * @event shaka.Player.TimelineRegionEnterEvent
  149.  * @description Fired when the playhead enters a timeline region.
  150.  * @property {string} type
  151.  *   'timelineregionenter'
  152.  * @property {shaka.extern.TimelineRegionInfo} detail
  153.  *   An object which contains a description of the region.
  154.  * @exportDoc
  155.  */
  158. /**
  159.  * @event shaka.Player.TimelineRegionExitEvent
  160.  * @description Fired when the playhead exits a timeline region.
  161.  * @property {string} type
  162.  *   'timelineregionexit'
  163.  * @property {shaka.extern.TimelineRegionInfo} detail
  164.  *   An object which contains a description of the region.
  165.  * @exportDoc
  166.  */
  168. /**
  169.  * @event shaka.Player.MediaQualityChangedEvent
  170.  * @description Fired when the media quality changes at the playhead.
  171.  * That may be caused by an adaptation change or a DASH period transition.
  172.  * Separate events are emitted for audio and video contentTypes.
  173.  * This is supported for only DASH streams at this time.
  174.  * @property {string} type
  175.  *   'mediaqualitychanged'
  176.  * @property {shaka.extern.MediaQualityInfo} mediaQuality
  177.  *   Information about media quality at the playhead position.
  178.  * @property {number} position
  179.  *   The playhead position.
  180.  * @exportDoc
  181.  */
  184. /**
  185.  * @event shaka.Player.BufferingEvent
  186.  * @description Fired when the player's buffering state changes.
  187.  * @property {string} type
  188.  *   'buffering'
  189.  * @property {boolean} buffering
  190.  *   True when the Player enters the buffering state.
  191.  *   False when the Player leaves the buffering state.
  192.  * @exportDoc
  193.  */
  196. /**
  197.  * @event shaka.Player.LoadingEvent
  198.  * @description Fired when the player begins loading. The start of loading is
  199.  *   defined as when the user has communicated intent to load content (i.e.
  200.  *   <code>Player.load</code> has been called).
  201.  * @property {string} type
  202.  *   'loading'
  203.  * @exportDoc
  204.  */
  207. /**
  208.  * @event shaka.Player.LoadedEvent
  209.  * @description Fired when the player ends the load.
  210.  * @property {string} type
  211.  *   'loaded'
  212.  * @exportDoc
  213.  */
  216. /**
  217.  * @event shaka.Player.UnloadingEvent
  218.  * @description Fired when the player unloads or fails to load.
  219.  *   Used by the Cast receiver to determine idle state.
  220.  * @property {string} type
  221.  *   'unloading'
  222.  * @exportDoc
  223.  */
  226. /**
  227.  * @event shaka.Player.TextTrackVisibilityEvent
  228.  * @description Fired when text track visibility changes.
  229.  * @property {string} type
  230.  *   'texttrackvisibility'
  231.  * @exportDoc
  232.  */
  235. /**
  236.  * @event shaka.Player.TracksChangedEvent
  237.  * @description Fired when the list of tracks changes.  For example, this will
  238.  *   happen when new tracks are added/removed or when track restrictions change.
  239.  * @property {string} type
  240.  *   'trackschanged'
  241.  * @exportDoc
  242.  */
  245. /**
  246.  * @event shaka.Player.AdaptationEvent
  247.  * @description Fired when an automatic adaptation causes the active tracks
  248.  *   to change.  Does not fire when the application calls
  249.  *   <code>selectVariantTrack()</code>, <code>selectTextTrack()</code>,
  250.  *   <code>selectAudioLanguage()</code>, or <code>selectTextLanguage()</code>.
  251.  * @property {string} type
  252.  *   'adaptation'
  253.  * @property {shaka.extern.Track} oldTrack
  254.  * @property {shaka.extern.Track} newTrack
  255.  * @exportDoc
  256.  */
  259. /**
  260.  * @event shaka.Player.VariantChangedEvent
  261.  * @description Fired when a call from the application caused a variant change.
  262.  *  Can be triggered by calls to <code>selectVariantTrack()</code> or
  263.  *  <code>selectAudioLanguage()</code>. Does not fire when an automatic
  264.  *  adaptation causes a variant change.
  265.  * @property {string} type
  266.  *   'variantchanged'
  267.  * @property {shaka.extern.Track} oldTrack
  268.  * @property {shaka.extern.Track} newTrack
  269.  * @exportDoc
  270.  */
  273. /**
  274.  * @event shaka.Player.TextChangedEvent
  275.  * @description Fired when a call from the application caused a text stream
  276.  *  change. Can be triggered by calls to <code>selectTextTrack()</code> or
  277.  *  <code>selectTextLanguage()</code>.
  278.  * @property {string} type
  279.  *   'textchanged'
  280.  * @exportDoc
  281.  */
  284. /**
  285.  * @event shaka.Player.ExpirationUpdatedEvent
  286.  * @description Fired when there is a change in the expiration times of an
  287.  *   EME session.
  288.  * @property {string} type
  289.  *   'expirationupdated'
  290.  * @exportDoc
  291.  */
  294. /**
  295.  * @event shaka.Player.ManifestParsedEvent
  296.  * @description Fired after the manifest has been parsed, but before anything
  297.  *   else happens. The manifest may contain streams that will be filtered out,
  298.  *   at this stage of the loading process.
  299.  * @property {string} type
  300.  *   'manifestparsed'
  301.  * @exportDoc
  302.  */
  305. /**
  306.  * @event shaka.Player.ManifestUpdatedEvent
  307.  * @description Fired after the manifest has been updated (live streams).
  308.  * @property {string} type
  309.  *   'manifestupdated'
  310.  * @property {boolean} isLive
  311.  *   True when the playlist is live. Useful to detect transition from live
  312.  *   to static playlist..
  313.  * @exportDoc
  314.  */
  317. /**
  318.  * @event shaka.Player.MetadataEvent
  319.  * @description Triggers after metadata associated with the stream is found.
  320.  *   Usually they are metadata of type ID3.
  321.  * @property {string} type
  322.  *   'metadata'
  323.  * @property {number} startTime
  324.  *   The time that describes the beginning of the range of the metadata to
  325.  *   which the cue applies.
  326.  * @property {?number} endTime
  327.  *   The time that describes the end of the range of the metadata to which
  328.  *   the cue applies.
  329.  * @property {string} metadataType
  330.  *   Type of metadata. Eg: org.id3 or org.mp4ra
  331.  * @property {shaka.extern.MetadataFrame} payload
  332.  *   The metadata itself
  333.  * @exportDoc
  334.  */
  337. /**
  338.  * @event shaka.Player.StreamingEvent
  339.  * @description Fired after the manifest has been parsed and track information
  340.  *   is available, but before streams have been chosen and before any segments
  341.  *   have been fetched.  You may use this event to configure the player based on
  342.  *   information found in the manifest.
  343.  * @property {string} type
  344.  *   'streaming'
  345.  * @exportDoc
  346.  */
  349. /**
  350.  * @event shaka.Player.AbrStatusChangedEvent
  351.  * @description Fired when the state of abr has been changed.
  352.  *    (Enabled or disabled).
  353.  * @property {string} type
  354.  *   'abrstatuschanged'
  355.  * @property {boolean} newStatus
  356.  *  The new status of the application. True for 'is enabled' and
  357.  *  false otherwise.
  358.  * @exportDoc
  359.  */
  362. /**
  363.  * @event shaka.Player.RateChangeEvent
  364.  * @description Fired when the video's playback rate changes.
  365.  *    This allows the PlayRateController to update it's internal rate field,
  366.  *    before the UI updates playback button with the newest playback rate.
  367.  * @property {string} type
  368.  *    'ratechange'
  369.  * @exportDoc
  370.  */
  373. /**
  374.  * @event shaka.Player.SegmentAppended
  375.  * @description Fired when a segment is appended to the media element.
  376.  * @property {string} type
  377.  *   'segmentappended'
  378.  * @property {number} start
  379.  *   The start time of the segment.
  380.  * @property {number} end
  381.  *   The end time of the segment.
  382.  * @property {string} contentType
  383.  *   The content type of the segment. E.g. 'video', 'audio', or 'text'.
  384.  * @exportDoc
  385.  */
  388. /**
  389.  * @event shaka.Player.SessionDataEvent
  390.  * @description Fired when the manifest parser find info about session data.
  391.  *    Specification: https://tools.ietf.org/html/rfc8216#section-4.3.4.4
  392.  * @property {string} type
  393.  *   'sessiondata'
  394.  * @property {string} id
  395.  *   The id of the session data.
  396.  * @property {string} uri
  397.  *   The uri with the session data info.
  398.  * @property {string} language
  399.  *   The language of the session data.
  400.  * @property {string} value
  401.  *   The value of the session data.
  402.  * @exportDoc
  403.  */
  406. /**
  407.  * @event shaka.Player.StallDetectedEvent
  408.  * @description Fired when a stall in playback is detected by the StallDetector.
  409.  *     Not all stalls are caused by gaps in the buffered ranges.
  410.  * @property {string} type
  411.  *   'stalldetected'
  412.  * @exportDoc
  413.  */
  416. /**
  417.  * @event shaka.Player.GapJumpedEvent
  418.  * @description Fired when the GapJumpingController jumps over a gap in the
  419.  *     buffered ranges.
  420.  * @property {string} type
  421.  *   'gapjumped'
  422.  * @exportDoc
  423.  */
  426. /**
  427.  * @event shaka.Player.KeyStatusChanged
  428.  * @description Fired when the key status changed.
  429.  * @property {string} type
  430.  *   'keystatuschanged'
  431.  * @exportDoc
  432.  */
  435. /**
  436.  * @event shaka.Player.StateChanged
  437.  * @description Fired when player state is changed.
  438.  * @property {string} type
  439.  *   'statechanged'
  440.  * @property {string} newstate
  441.  *   The new state.
  442.  * @exportDoc
  443.  */
  446. /**
  447.  * @event shaka.Player.Started
  448.  * @description Fires when the content starts playing.
  449.  *     Only for VoD.
  450.  * @property {string} type
  451.  *   'started'
  452.  * @exportDoc
  453.  */
  456. /**
  457.  * @event shaka.Player.FirstQuartile
  458.  * @description Fires when the content playhead crosses first quartile.
  459.  *     Only for VoD.
  460.  * @property {string} type
  461.  *   'firstquartile'
  462.  * @exportDoc
  463.  */
  466. /**
  467.  * @event shaka.Player.Midpoint
  468.  * @description Fires when the content playhead crosses midpoint.
  469.  *     Only for VoD.
  470.  * @property {string} type
  471.  *   'midpoint'
  472.  * @exportDoc
  473.  */
  476. /**
  477.  * @event shaka.Player.ThirdQuartile
  478.  * @description Fires when the content playhead crosses third quartile.
  479.  *     Only for VoD.
  480.  * @property {string} type
  481.  *   'thirdquartile'
  482.  * @exportDoc
  483.  */
  486. /**
  487.  * @event shaka.Player.Complete
  488.  * @description Fires when the content completes playing.
  489.  *     Only for VoD.
  490.  * @property {string} type
  491.  *   'complete'
  492.  * @exportDoc
  493.  */
  496. /**
  497.  * @summary The main player object for Shaka Player.
  498.  *
  499.  * @implements {shaka.util.IDestroyable}
  500.  * @export
  501.  */
  502. shaka.Player = class extends shaka.util.FakeEventTarget {
  503.   /**
  504.    * @param {HTMLMediaElement=} mediaElement
  505.    *    When provided, the player will attach to <code>mediaElement</code>,
  506.    *    similar to calling <code>attach</code>. When not provided, the player
  507.    *    will remain detached.
  508.    * @param {function(shaka.Player)=} dependencyInjector Optional callback
  509.    *   which is called to inject mocks into the Player.  Used for testing.
  510.    */
  511.   constructor(mediaElement, dependencyInjector) {
  512.     super();
  514.     /** @private {shaka.Player.LoadMode} */
  515.     this.loadMode_ = shaka.Player.LoadMode.NOT_LOADED;
  517.     /** @private {HTMLMediaElement} */
  518.     this.video_ = null;
  520.     /** @private {HTMLElement} */
  521.     this.videoContainer_ = null;
  523.     /**
  524.      * Since we may not always have a text displayer created (e.g. before |load|
  525.      * is called), we need to track what text visibility SHOULD be so that we
  526.      * can ensure that when we create the text displayer. When we create our
  527.      * text displayer, we will use this to show (or not show) text as per the
  528.      * user's requests.
  529.      *
  530.      * @private {boolean}
  531.      */
  532.     this.isTextVisible_ = false;
  534.     /**
  535.      * For listeners scoped to the lifetime of the Player instance.
  536.      * @private {shaka.util.EventManager}
  537.      */
  538.     this.globalEventManager_ = new shaka.util.EventManager();
  540.     /**
  541.      * For listeners scoped to the lifetime of the media element attachment.
  542.      * @private {shaka.util.EventManager}
  543.      */
  544.     this.attachEventManager_ = new shaka.util.EventManager();
  546.     /**
  547.      * For listeners scoped to the lifetime of the loaded content.
  548.      * @private {shaka.util.EventManager}
  549.      */
  550.     this.loadEventManager_ = new shaka.util.EventManager();
  552.     /** @private {shaka.net.NetworkingEngine} */
  553.     this.networkingEngine_ = null;
  555.     /** @private {shaka.media.DrmEngine} */
  556.     this.drmEngine_ = null;
  558.     /** @private {shaka.media.MediaSourceEngine} */
  559.     this.mediaSourceEngine_ = null;
  561.     /** @private {shaka.media.Playhead} */
  562.     this.playhead_ = null;
  564.     /**
  565.      * Incremented whenever a top-level operation (load, attach, etc) is
  566.      * performed.
  567.      * Used to determine if a load operation has been interrupted.
  568.      * @private {number}
  569.      */
  570.     this.operationId_ = 0;
  572.     /** @private {!shaka.util.Mutex} */
  573.     this.mutex_ = new shaka.util.Mutex();
  575.     /**
  576.      * The playhead observers are used to monitor the position of the playhead
  577.      * and some other source of data (e.g. buffered content), and raise events.
  578.      *
  579.      * @private {shaka.media.PlayheadObserverManager}
  580.      */
  581.     this.playheadObservers_ = null;
  583.     /**
  584.      * This is our control over the playback rate of the media element. This
  585.      * provides the missing functionality that we need to provide trick play,
  586.      * for example a negative playback rate.
  587.      *
  588.      * @private {shaka.media.PlayRateController}
  589.      */
  590.     this.playRateController_ = null;
  592.     /** @private {shaka.media.BufferingObserver} */
  593.     this.bufferObserver_ = null;
  595.     /** @private {shaka.media.RegionTimeline} */
  596.     this.regionTimeline_ = null;
  598.     /** @private {shaka.util.CmcdManager} */
  599.     this.cmcdManager_ = null;
  601.     // This is the canvas element that will be used for rendering LCEVC
  602.     // enhanced frames.
  603.     /** @private {?HTMLCanvasElement} */
  604.     this.lcevcCanvas_ = null;
  606.     // This is the LCEVC Decoder object to decode LCEVC.
  607.     /** @private {?shaka.lcevc.Dec} */
  608.     this.lcevcDec_ = null;
  610.     /** @private {shaka.media.QualityObserver} */
  611.     this.qualityObserver_ = null;
  613.     /** @private {shaka.media.StreamingEngine} */
  614.     this.streamingEngine_ = null;
  616.     /** @private {shaka.extern.ManifestParser} */
  617.     this.parser_ = null;
  619.     /** @private {?shaka.extern.ManifestParser.Factory} */
  620.     this.parserFactory_ = null;
  622.     /** @private {?shaka.extern.Manifest} */
  623.     this.manifest_ = null;
  625.     /** @private {?string} */
  626.     this.assetUri_ = null;
  628.     /** @private {?number} */
  629.     this.startTime_ = null;
  631.     /** @private {boolean} */
  632.     this.fullyLoaded_ = false;
  634.     /** @private {shaka.extern.AbrManager} */
  635.     this.abrManager_ = null;
  637.     /**
  638.      * The factory that was used to create the abrManager_ instance.
  639.      * @private {?shaka.extern.AbrManager.Factory}
  640.      */
  641.     this.abrManagerFactory_ = null;
  643.     /**
  644.      * Contains an ID for use with creating streams.  The manifest parser should
  645.      * start with small IDs, so this starts with a large one.
  646.      * @private {number}
  647.      */
  648.     this.nextExternalStreamId_ = 1e9;
  650.     /** @private {!Array.<shaka.extern.Stream>} */
  651.     this.externalSrcEqualsThumbnailsStreams_ = [];
  653.     /** @private {number} */
  654.     this.completionPercent_ = NaN;
  656.     /** @private {?shaka.extern.PlayerConfiguration} */
  657.     this.config_ = this.defaultConfig_();
  659.     /**
  660.      * The TextDisplayerFactory that was last used to make a text displayer.
  661.      * Stored so that we can tell if a new type of text displayer is desired.
  662.      * @private {?shaka.extern.TextDisplayer.Factory}
  663.      */
  664.     this.lastTextFactory_;
  666.     /** @private {{width: number, height: number}} */
  667.     this.maxHwRes_ = {width: Infinity, height: Infinity};
  669.     /** @private {shaka.util.Stats} */
  670.     this.stats_ = null;
  672.     /** @private {!shaka.media.AdaptationSetCriteria} */
  673.     this.currentAdaptationSetCriteria_ =
  674.         new shaka.media.PreferenceBasedCriteria(
  675.             this.config_.preferredAudioLanguage,
  676.             this.config_.preferredVariantRole,
  677.             this.config_.preferredAudioChannelCount,
  678.             this.config_.preferredVideoHdrLevel,
  679.             this.config_.preferredVideoLayout,
  680.             this.config_.preferredAudioLabel,
  681.             this.config_.mediaSource.codecSwitchingStrategy,
  682.             this.config_.manifest.dash.enableAudioGroups);
  684.     /** @private {string} */
  685.     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
  687.     /** @private {string} */
  688.     this.currentTextRole_ = this.config_.preferredTextRole;
  690.     /** @private {boolean} */
  691.     this.currentTextForced_ = this.config_.preferForcedSubs;
  693.     /** @private {!Array.<function():(!Promise|undefined)>} */
  694.     this.cleanupOnUnload_ = [];
  696.     if (dependencyInjector) {
  697.       dependencyInjector(this);
  698.     }
  701.     // Create the CMCD manager so client data can be attached to all requests
  702.     this.cmcdManager_ = this.createCmcd_();
  704.     this.networkingEngine_ = this.createNetworkingEngine();
  705.     this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
  707.     /** @private {shaka.extern.IAdManager} */
  708.     this.adManager_ = null;
  710.     if (shaka.Player.adManagerFactory_) {
  711.       this.adManager_ = shaka.Player.adManagerFactory_();
  712.     }
  714.     // If the browser comes back online after being offline, then try to play
  715.     // again.
  716.     this.globalEventManager_.listen(window, 'online', () => {
  717.       this.restoreDisabledVariants_();
  718.       this.retryStreaming();
  719.     });
  721.     /** @private {shaka.util.Timer} */
  722.     this.checkVariantsTimer_ =
  723.         new shaka.util.Timer(() => this.checkVariants_());
  725.     // Even though |attach| will start in later interpreter cycles, it should be
  726.     // the LAST thing we do in the constructor because conceptually it relies on
  727.     // player having been initialized.
  728.     if (mediaElement) {
  729.       shaka.Deprecate.deprecateFeature(5,
  730.           'Player',
  731.           'Please migrate from initializing Player with a mediaElement; ' +
  732.           'use the attach method instead.');
  733.       this.attach(mediaElement, /* initializeMediaSource= */ true);
  734.     }
  735.   }
  737.   /**
  738.    * Create a shaka.lcevc.Dec object
  739.    * @param {shaka.extern.LcevcConfiguration} config
  740.    * @private
  741.    */
  742.   createLcevcDec_(config) {
  743.     if (this.lcevcDec_ == null) {
  744.       this.lcevcDec_ = new shaka.lcevc.Dec(
  745.           /** @type {HTMLVideoElement} */ (this.video_),
  746.           this.lcevcCanvas_,
  747.           config,
  748.       );
  749.       if (this.mediaSourceEngine_) {
  750.         this.mediaSourceEngine_.updateLcevcDec(this.lcevcDec_);
  751.       }
  752.     }
  753.   }
  755.   /**
  756.    * Close a shaka.lcevc.Dec object if present and hide the canvas.
  757.    * @private
  758.    */
  759.   closeLcevcDec_() {
  760.     if (this.lcevcDec_ != null) {
  761.       this.lcevcDec_.hideCanvas();
  762.       this.lcevcDec_.release();
  763.       this.lcevcDec_ = null;
  764.     }
  765.   }
  767.   /**
  768.    * Setup shaka.lcevc.Dec object
  769.    * @param {?shaka.extern.PlayerConfiguration} config
  770.    * @private
  771.    */
  772.   setupLcevc_(config) {
  773.     if (config.lcevc.enabled) {
  774.       const tracks = this.getVariantTracks();
  775.       if (tracks && tracks[0] && tracks[0].videoMimeType == 'video/mp2t') {
  776.         const edge = shaka.util.Platform.isEdge() ||
  777.           shaka.util.Platform.isLegacyEdge();
  778.         if (edge) {
  779.           if (!config.mediaSource.forceTransmux) {
  780.             // If forceTransmux is disabled for Microsoft Edge, LCEVC data
  781.             // is stripped out in case of a MPEG-2 TS container.
  782.             // Hence the warning for Microsoft Edge when playing content with
  783.             // MPEG-2 TS container.
  784.             shaka.log.alwaysWarn('LCEVC Warning: For MPEG-2 TS decoding '+
  785.             'the config.mediaSource.forceTransmux must be enabled.');
  786.           }
  787.         }
  788.       }
  789.       this.closeLcevcDec_();
  790.       this.createLcevcDec_(config.lcevc);
  791.     } else {
  792.       this.closeLcevcDec_();
  793.     }
  794.   }
  796.   /**
  797.    * @param {!shaka.util.FakeEvent.EventName} name
  798.    * @param {Map.<string, Object>=} data
  799.    * @return {!shaka.util.FakeEvent}
  800.    * @private
  801.    */
  802.   makeEvent_(name, data) {
  803.     return new shaka.util.FakeEvent(name, data);
  804.   }
  806.   /**
  807.    * After destruction, a Player object cannot be used again.
  808.    *
  809.    * @override
  810.    * @export
  811.    */
  812.   async destroy() {
  813.     // Make sure we only execute the destroy logic once.
  814.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  815.       return;
  816.     }
  818.     // If LCEVC Decoder exists close it.
  819.     this.closeLcevcDec_();
  821.     const detachPromise = this.detach();
  823.     // Mark as "dead". This should stop external-facing calls from changing our
  824.     // internal state any more. This will stop calls to |attach|, |detach|, etc.
  825.     // from interrupting our final move to the detached state.
  826.     this.loadMode_ = shaka.Player.LoadMode.DESTROYED;
  828.     await detachPromise;
  830.     // Tear-down the event managers to ensure handlers stop firing.
  831.     if (this.globalEventManager_) {
  832.       this.globalEventManager_.release();
  833.       this.globalEventManager_ = null;
  834.     }
  835.     if (this.attachEventManager_) {
  836.       this.attachEventManager_.release();
  837.       this.attachEventManager_ = null;
  838.     }
  839.     if (this.loadEventManager_) {
  840.       this.loadEventManager_.release();
  841.       this.loadEventManager_ = null;
  842.     }
  844.     this.abrManagerFactory_ = null;
  845.     this.config_ = null;
  846.     this.stats_ = null;
  847.     this.videoContainer_ = null;
  848.     this.cmcdManager_ = null;
  850.     if (this.networkingEngine_) {
  851.       await this.networkingEngine_.destroy();
  852.       this.networkingEngine_ = null;
  853.     }
  855.     if (this.abrManager_) {
  856.       this.abrManager_.release();
  857.       this.abrManager_ = null;
  858.     }
  860.     // FakeEventTarget implements IReleasable
  861.     super.release();
  862.   }
  864.   /**
  865.    * Registers a plugin callback that will be called with
  866.    * <code>support()</code>.  The callback will return the value that will be
  867.    * stored in the return value from <code>support()</code>.
  868.    *
  869.    * @param {string} name
  870.    * @param {function():*} callback
  871.    * @export
  872.    */
  873.   static registerSupportPlugin(name, callback) {
  874.     shaka.Player.supportPlugins_[name] = callback;
  875.   }
  877.   /**
  878.    * Set a factory to create an ad manager during player construction time.
  879.    * This method needs to be called bafore instantiating the Player class.
  880.    *
  881.    * @param {!shaka.extern.IAdManager.Factory} factory
  882.    * @export
  883.    */
  884.   static setAdManagerFactory(factory) {
  885.     shaka.Player.adManagerFactory_ = factory;
  886.   }
  888.   /**
  889.    * Return whether the browser provides basic support.  If this returns false,
  890.    * Shaka Player cannot be used at all.  In this case, do not construct a
  891.    * Player instance and do not use the library.
  892.    *
  893.    * @return {boolean}
  894.    * @export
  895.    */
  896.   static isBrowserSupported() {
  897.     if (!window.Promise) {
  898.       shaka.log.alwaysWarn('A Promise implementation or polyfill is required');
  899.     }
  901.     // Basic features needed for the library to be usable.
  902.     const basicSupport = !!window.Promise && !!window.Uint8Array &&
  903.                          // eslint-disable-next-line no-restricted-syntax
  904.                          !!Array.prototype.forEach;
  905.     if (!basicSupport) {
  906.       return false;
  907.     }
  909.     // We do not support IE
  910.     if (shaka.util.Platform.isIE()) {
  911.       return false;
  912.     }
  914.     const safariVersion = shaka.util.Platform.safariVersion();
  915.     if (safariVersion && safariVersion < 9) {
  916.       return false;
  917.     }
  919.     // DRM support is not strictly necessary, but the APIs at least need to be
  920.     // there.  Our no-op DRM polyfill should handle that.
  921.     // TODO(#1017): Consider making even DrmEngine optional.
  922.     const drmSupport = shaka.media.DrmEngine.isBrowserSupported();
  923.     if (!drmSupport) {
  924.       return false;
  925.     }
  927.     // If we have MediaSource (MSE) support, we should be able to use Shaka.
  928.     if (shaka.util.Platform.supportsMediaSource()) {
  929.       return true;
  930.     }
  932.     // If we don't have MSE, we _may_ be able to use Shaka.  Look for native HLS
  933.     // support, and call this platform usable if we have it.
  934.     return shaka.util.Platform.supportsMediaType('application/x-mpegurl');
  935.   }
  937.   /**
  938.    * Probes the browser to determine what features are supported.  This makes a
  939.    * number of requests to EME/MSE/etc which may result in user prompts.  This
  940.    * should only be used for diagnostics.
  941.    *
  942.    * <p>
  943.    * NOTE: This may show a request to the user for permission.
  944.    *
  945.    * @see https://bit.ly/2ywccmH
  946.    * @param {boolean=} promptsOkay
  947.    * @return {!Promise.<shaka.extern.SupportType>}
  948.    * @export
  949.    */
  950.   static async probeSupport(promptsOkay=true) {
  951.     goog.asserts.assert(shaka.Player.isBrowserSupported(),
  952.         'Must have basic support');
  953.     let drm = {};
  954.     if (promptsOkay) {
  955.       drm = await shaka.media.DrmEngine.probeSupport();
  956.     }
  957.     const manifest = shaka.media.ManifestParser.probeSupport();
  958.     const media = shaka.media.MediaSourceEngine.probeSupport();
  959.     const ret = {
  960.       manifest: manifest,
  961.       media: media,
  962.       drm: drm,
  963.     };
  965.     const plugins = shaka.Player.supportPlugins_;
  966.     for (const name in plugins) {
  967.       ret[name] = plugins[name]();
  968.     }
  970.     return ret;
  971.   }
  973.   /**
  974.    * Makes a fires an event corresponding to entering a state of the loading
  975.    * process.
  976.    * @param {string} nodeName
  977.    * @private
  978.    */
  979.   makeStateChangeEvent_(nodeName) {
  980.     this.dispatchEvent(this.makeEvent_(
  981.         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
  982.         /* data= */ (new Map()).set('state', nodeName)));
  983.   }
  985.   /**
  986.    * Attaches the player to a media element.
  987.    * If the player was already attached to a media element, first detaches from
  988.    * that media element.
  989.    *
  990.    * @param {!HTMLMediaElement} mediaElement
  991.    * @param {boolean=} initializeMediaSource
  992.    * @return {!Promise}
  993.    * @export
  994.    */
  995.   async attach(mediaElement, initializeMediaSource = true) {
  996.     // Do not allow the player to be used after |destroy| is called.
  997.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  998.       throw this.createAbortLoadError_();
  999.     }
  1001.     if (this.video_ && this.video_ != mediaElement) {
  1002.       await this.detach();
  1003.     }
  1005.     if (await this.atomicOperationAcquireMutex_('attach')) {
  1006.       return;
  1007.     }
  1009.     try {
  1010.       this.makeStateChangeEvent_('attach');
  1012.       const onError = (error) => this.onVideoError_(error);
  1013.       this.attachEventManager_.listen(mediaElement, 'error', onError);
  1014.       this.video_ = mediaElement;
  1016.       // Only initialize media source if the platform supports it.
  1017.       if (initializeMediaSource &&
  1018.           shaka.util.Platform.supportsMediaSource() &&
  1019.           !this.mediaSourceEngine_) {
  1020.         await this.initializeMediaSourceEngineInner_();
  1021.       }
  1022.     } catch (error) {
  1023.       await this.detach();
  1024.       throw error;
  1025.     } finally {
  1026.       this.mutex_.release();
  1027.     }
  1028.   }
  1031.   /**
  1032.    * Calling <code>attachCanvas</code> will tell the player to set canvas
  1033.    * element for LCEVC decoding.
  1034.    *
  1035.    * @param {HTMLCanvasElement} canvas
  1036.    * @export
  1037.    */
  1038.   attachCanvas(canvas) {
  1039.     this.lcevcCanvas_ = canvas;
  1040.   }
  1042.   /**
  1043.    * Detach the player from the current media element. Leaves the player in a
  1044.    * state where it cannot play media, until it has been attached to something
  1045.    * else.
  1046.    *
  1047.    * @param {boolean=} keepAdManager
  1048.    *
  1049.    * @return {!Promise}
  1050.    * @export
  1051.    */
  1052.   async detach(keepAdManager = false) {
  1053.     // Do not allow the player to be used after |destroy| is called.
  1054.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  1055.       throw this.createAbortLoadError_();
  1056.     }
  1058.     await this.unload(/* initializeMediaSource= */ false, keepAdManager);
  1060.     if (await this.atomicOperationAcquireMutex_('detach')) {
  1061.       return;
  1062.     }
  1064.     try {
  1065.       // If we were going from "detached" to "detached" we wouldn't have
  1066.       // a media element to detach from.
  1067.       if (this.video_) {
  1068.         this.attachEventManager_.removeAll();
  1069.         this.video_ = null;
  1070.       }
  1072.       this.makeStateChangeEvent_('detach');
  1074.       if (this.adManager_ && !keepAdManager) {
  1075.         // The ad manager is specific to the video, so detach it too.
  1076.         this.adManager_.release();
  1077.       }
  1078.     } finally {
  1079.       this.mutex_.release();
  1080.     }
  1081.   }
  1083.   /**
  1084.    * Tries to acquire the mutex, and then returns if the operation should end
  1085.    * early due to someone else starting a mutex-acquiring operation.
  1086.    * Meant for operations that can't be interrupted midway through (e.g.
  1087.    * everything but load).
  1088.    * @param {string} mutexIdentifier
  1089.    * @return {!Promise.<boolean>} endEarly If false, the calling context will
  1090.    *   need to release the mutex.
  1091.    * @private
  1092.    */
  1093.   async atomicOperationAcquireMutex_(mutexIdentifier) {
  1094.     const operationId = ++this.operationId_;
  1095.     await this.mutex_.acquire(mutexIdentifier);
  1096.     if (operationId != this.operationId_) {
  1097.       this.mutex_.release();
  1098.       return true;
  1099.     }
  1100.     return false;
  1101.   }
  1103.   /**
  1104.    * Unloads the currently playing stream, if any.
  1105.    *
  1106.    * @param {boolean=} initializeMediaSource
  1107.    * @param {boolean=} keepAdManager
  1108.    * @return {!Promise}
  1109.    * @export
  1110.    */
  1111.   async unload(initializeMediaSource = true, keepAdManager = false) {
  1112.     // Set the load mode to unload right away so that all the public methods
  1113.     // will stop using the internal components. We need to make sure that we
  1114.     // are not overriding the destroyed state because we will unload when we are
  1115.     // destroying the player.
  1116.     if (this.loadMode_ != shaka.Player.LoadMode.DESTROYED) {
  1117.       this.loadMode_ = shaka.Player.LoadMode.NOT_LOADED;
  1118.     }
  1120.     if (await this.atomicOperationAcquireMutex_('unload')) {
  1121.       return;
  1122.     }
  1124.     try {
  1125.       this.fullyLoaded_ = false;
  1126.       this.makeStateChangeEvent_('unload');
  1128.       // If the platform does not support media source, we will never want to
  1129.       // initialize media source.
  1130.       if (initializeMediaSource && !shaka.util.Platform.supportsMediaSource()) {
  1131.         initializeMediaSource = false;
  1132.       }
  1134.       // If LCEVC Decoder exists close it.
  1135.       this.closeLcevcDec_();
  1137.       // Run any general cleanup tasks now.  This should be here at the top,
  1138.       // right after setting loadMode_, so that internal components still exist
  1139.       // as they did when the cleanup tasks were registered in the array.
  1140.       const cleanupTasks = this.cleanupOnUnload_.map((cb) => cb());
  1141.       this.cleanupOnUnload_ = [];
  1142.       await Promise.all(cleanupTasks);
  1144.       // Dispatch the unloading event.
  1145.       this.dispatchEvent(
  1146.           this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
  1148.       // Release the region timeline, which is created when parsing the
  1149.       // manifest.
  1150.       if (this.regionTimeline_) {
  1151.         this.regionTimeline_.release();
  1152.         this.regionTimeline_ = null;
  1153.       }
  1155.       // In most cases we should have a media element. The one exception would
  1156.       // be if there was an error and we, by chance, did not have a media
  1157.       // element.
  1158.       if (this.video_) {
  1159.         this.loadEventManager_.removeAll();
  1160.       }
  1162.       // Stop the variant checker timer
  1163.       this.checkVariantsTimer_.stop();
  1165.       // Some observers use some playback components, shutting down the
  1166.       // observers first ensures that they don't try to use the playback
  1167.       // components mid-destroy.
  1168.       if (this.playheadObservers_) {
  1169.         this.playheadObservers_.release();
  1170.         this.playheadObservers_ = null;
  1171.       }
  1173.       // Stop the parser early. Since it is at the start of the pipeline, it
  1174.       // should be start early to avoid is pushing new data downstream.
  1175.       if (this.parser_) {
  1176.         await this.parser_.stop();
  1177.         this.parser_ = null;
  1178.         this.parserFactory_ = null;
  1179.       }
  1181.       // Abr Manager will tell streaming engine what to do, so we need to stop
  1182.       // it before we destroy streaming engine. Unlike with the other
  1183.       // components, we do not release the instance, we will reuse it in later
  1184.       // loads.
  1185.       if (this.abrManager_) {
  1186.         await this.abrManager_.stop();
  1187.       }
  1189.       // Streaming engine will push new data to media source engine, so we need
  1190.       // to shut it down before destroy media source engine.
  1191.       if (this.streamingEngine_) {
  1192.         await this.streamingEngine_.destroy();
  1193.         this.streamingEngine_ = null;
  1194.       }
  1196.       if (this.playRateController_) {
  1197.         this.playRateController_.release();
  1198.         this.playRateController_ = null;
  1199.       }
  1201.       // Playhead is used by StreamingEngine, so we can't destroy this until
  1202.       // after StreamingEngine has stopped.
  1203.       if (this.playhead_) {
  1204.         this.playhead_.release();
  1205.         this.playhead_ = null;
  1206.       }
  1208.       // Media source engine holds onto the media element, and in order to
  1209.       // detach the media keys (with drm engine), we need to break the
  1210.       // connection between media source engine and the media element.
  1211.       if (this.mediaSourceEngine_) {
  1212.         await this.mediaSourceEngine_.destroy();
  1213.         this.mediaSourceEngine_ = null;
  1214.       }
  1216.       if (this.adManager_ && !keepAdManager) {
  1217.         this.adManager_.onAssetUnload();
  1218.       }
  1220.       if (this.video_) {
  1221.         // Remove all track nodes
  1222.         shaka.util.Dom.removeAllChildren(this.video_);
  1223.       }
  1225.       // In order to unload a media element, we need to remove the src attribute
  1226.       // and then load again. When we destroy media source engine, this will be
  1227.       // done for us, but for src=, we need to do it here.
  1228.       //
  1229.       // DrmEngine requires this to be done before we destroy DrmEngine itself.
  1230.       if (this.video_ && this.video_.src) {
  1231.         // TODO: Investigate this more.  Only reproduces on Firefox 69.
  1232.         // Introduce a delay before detaching the video source.  We are seeing
  1233.         // spurious Promise rejections involving an AbortError in our tests
  1234.         // otherwise.
  1235.         await new Promise(
  1236.             (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  1238.         this.video_.removeAttribute('src');
  1239.         this.video_.load();
  1240.       }
  1242.       if (this.drmEngine_) {
  1243.         await this.drmEngine_.destroy();
  1244.         this.drmEngine_ = null;
  1245.       }
  1247.       this.assetUri_ = null;
  1248.       this.bufferObserver_ = null;
  1250.       if (this.manifest_) {
  1251.         for (const variant of this.manifest_.variants) {
  1252.           for (const stream of [variant.audio, variant.video]) {
  1253.             if (stream && stream.segmentIndex) {
  1254.               stream.segmentIndex.release();
  1255.             }
  1256.           }
  1257.         }
  1258.         for (const stream of this.manifest_.textStreams) {
  1259.           if (stream.segmentIndex) {
  1260.             stream.segmentIndex.release();
  1261.           }
  1262.         }
  1263.       }
  1265.       this.manifest_ = null;
  1266.       this.stats_ = new shaka.util.Stats(); // Replace with a clean object.
  1267.       this.lastTextFactory_ = null;
  1269.       this.externalSrcEqualsThumbnailsStreams_ = [];
  1271.       this.completionPercent_ = NaN;
  1273.       // Make sure that the app knows of the new buffering state.
  1274.       this.updateBufferState_();
  1275.     } finally {
  1276.       this.mutex_.release();
  1277.     }
  1279.     if (initializeMediaSource && shaka.util.Platform.supportsMediaSource() &&
  1280.         !this.mediaSourceEngine_) {
  1281.       await this.initializeMediaSourceEngineInner_();
  1282.     }
  1283.   }
  1285.   /**
  1286.    * Provides a way to update the stream start position during the media loading
  1287.    * process. Can for example be called from the <code>manifestparsed</code>
  1288.    * event handler to update the start position based on information in the
  1289.    * manifest.
  1290.    *
  1291.    * @param {number} startTime
  1292.    * @export
  1293.    */
  1294.   updateStartTime(startTime) {
  1295.     this.startTime_ = startTime;
  1296.   }
  1298.   /**
  1299.    * Loads a new stream.
  1300.    * If another stream was already playing, first unloads that stream.
  1301.    *
  1302.    * @param {string} assetUri
  1303.    * @param {?number=} startTime
  1304.    *    When <code>startTime</code> is <code>null</code> or
  1305.    *    <code>undefined</code>, playback will start at the default start time (0
  1306.    *    for VOD and liveEdge for LIVE).
  1307.    * @param {?string=} mimeType
  1308.    * @return {!Promise}
  1309.    * @export
  1310.    */
  1311.   async load(assetUri, startTime = null, mimeType) {
  1312.     // Do not allow the player to be used after |destroy| is called.
  1313.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  1314.       throw this.createAbortLoadError_();
  1315.     }
  1317.     // Quickly acquire the mutex, so this will wait for other top-level
  1318.     // operations.
  1319.     await this.mutex_.acquire('load');
  1320.     this.mutex_.release();
  1322.     if (!this.video_) {
  1323.       throw new shaka.util.Error(
  1324.           shaka.util.Error.Severity.CRITICAL,
  1325.           shaka.util.Error.Category.PLAYER,
  1326.           shaka.util.Error.Code.NO_VIDEO_ELEMENT);
  1327.     }
  1329.     if (this.assetUri_) {
  1330.       await this.unload(/* initializeMediaSource= */ false);
  1331.     }
  1333.     // Add a mechanism to detect if the load process has been interrupted by a
  1334.     // call to another top-level operation (unload, load, etc).
  1335.     const operationId = ++this.operationId_;
  1336.     const detectInterruption = () => {
  1337.       if (this.operationId_ != operationId) {
  1338.         throw this.createAbortLoadError_();
  1339.       }
  1340.     };
  1342.     /**
  1343.      * Wraps a given operation with mutex.acquire and mutex.release, along with
  1344.      * calls to detectInterruption, to catch any other top-level calls happening
  1345.      * while waiting for the mutex.
  1346.      * @param {function():!Promise} operation
  1347.      * @param {string} mutexIdentifier
  1348.      * @return {!Promise}
  1349.      */
  1350.     const mutexWrapOperation = async (operation, mutexIdentifier) => {
  1351.       try {
  1352.         await this.mutex_.acquire(mutexIdentifier);
  1353.         detectInterruption();
  1354.         await operation();
  1355.         detectInterruption();
  1356.       } finally {
  1357.         this.mutex_.release();
  1358.       }
  1359.     };
  1361.     try {
  1362.       this.startTime_ = startTime;
  1363.       this.fullyLoaded_ = false;
  1365.       // We dispatch the loading event when someone calls |load| because we want
  1366.       // to surface the user intent.
  1367.       this.dispatchEvent(this.makeEvent_(
  1368.           shaka.util.FakeEvent.EventName.Loading));
  1370.       const startTimeOfLoad = Date.now() / 1000;
  1372.       // Stats are for a single playback/load session. Stats must be initialized
  1373.       // before we allow calls to |updateStateHistory|.
  1374.       this.stats_ = new shaka.util.Stats();
  1376.       this.assetUri_ = assetUri;
  1378.       if (!mimeType) {
  1379.         await mutexWrapOperation(async () => {
  1380.           mimeType = await this.guessMimeType_();
  1381.         }, 'guessMimeType_');
  1382.       }
  1383.       const shouldUseSrcEquals = this.shouldUseSrcEquals_(assetUri, mimeType);
  1384.       if (shouldUseSrcEquals) {
  1385.         await mutexWrapOperation(async () => {
  1386.           goog.asserts.assert(mimeType, 'We should know the mimeType by now!');
  1387.           await this.initializeSrcEqualsDrmInner_(mimeType);
  1388.         }, 'initializeSrcEqualsDrmInner_');
  1389.         await mutexWrapOperation(async () => {
  1390.           goog.asserts.assert(mimeType, 'We should know the mimeType by now!');
  1391.           await this.srcEqualsInner_(startTimeOfLoad, mimeType);
  1392.         }, 'srcEqualsInner_');
  1393.       } else {
  1394.         if (!this.mediaSourceEngine_) {
  1395.           await mutexWrapOperation(async () => {
  1396.             await this.initializeMediaSourceEngineInner_();
  1397.           }, 'initializeMediaSourceEngineInner_');
  1398.         }
  1399.         await mutexWrapOperation(async () => {
  1400.           await this.parseManifestInner_(mimeType);
  1401.         }, 'parseManifestInner_');
  1402.         await mutexWrapOperation(async () => {
  1403.           await this.initializeDrmInner_();
  1404.         }, 'initializeDrmInner_');
  1405.         await mutexWrapOperation(async () => {
  1406.           await this.loadInner_(startTimeOfLoad);
  1407.         }, 'loadInner_');
  1408.       }
  1409.       this.dispatchEvent(this.makeEvent_(
  1410.           shaka.util.FakeEvent.EventName.Loaded));
  1411.     } catch (error) {
  1412.       if (error.code != shaka.util.Error.Code.LOAD_INTERRUPTED) {
  1413.         await this.unload(/* initializeMediaSource= */ false);
  1414.       }
  1415.       throw error;
  1416.     }
  1417.   }
  1419.   /**
  1420.    * Determines the mimeType of the given asset, if we are not told that inside
  1421.    * the loading process.
  1422.    *
  1423.    * @return {!Promise.<?string>} mimeType
  1424.    * @private
  1425.    */
  1426.   async guessMimeType_() {
  1427.     goog.asserts.assert(this.assetUri_, 'should have a uri by now.');
  1429.     // If no MIME type is provided, and we can't base it on extension, make a
  1430.     // HEAD request to determine it.
  1431.     goog.asserts.assert(this.networkingEngine_, 'Should have a net engine!');
  1432.     const retryParams = this.config_.manifest.retryParameters;
  1433.     let mimeType = await shaka.net.NetworkingUtils.getMimeType(
  1434.         this.assetUri_, this.networkingEngine_, retryParams);
  1435.     if (mimeType == 'application/x-mpegurl' && shaka.util.Platform.isApple()) {
  1436.       mimeType = 'application/vnd.apple.mpegurl';
  1437.     }
  1438.     return mimeType;
  1439.   }
  1441.   /**
  1442.    * Determines if we should use src equals, based on the the mimeType (if
  1443.    * known), the URI, and platform information.
  1444.    *
  1445.    * @param {string} assetUri
  1446.    * @param {?string=} mimeType
  1447.    * @return {boolean}
  1448.    *    |true| if the content should be loaded with src=, |false| if the content
  1449.    *    should be loaded with MediaSource.
  1450.    * @private
  1451.    */
  1452.   shouldUseSrcEquals_(assetUri, mimeType) {
  1453.     const Platform = shaka.util.Platform;
  1454.     const MimeUtils = shaka.util.MimeUtils;
  1456.     // If we are using a platform that does not support media source, we will
  1457.     // fall back to src= to handle all playback.
  1458.     if (!Platform.supportsMediaSource()) {
  1459.       return true;
  1460.     }
  1462.     if (mimeType) {
  1463.       // If we have a MIME type, check if the browser can play it natively.
  1464.       // This will cover both single files and native HLS.
  1465.       const mediaElement = this.video_ || Platform.anyMediaElement();
  1466.       const canPlayNatively = mediaElement.canPlayType(mimeType) != '';
  1468.       // If we can't play natively, then src= isn't an option.
  1469.       if (!canPlayNatively) {
  1470.         return false;
  1471.       }
  1473.       const canPlayMediaSource =
  1474.           shaka.media.ManifestParser.isSupported(mimeType);
  1476.       // If MediaSource isn't an option, the native option is our only chance.
  1477.       if (!canPlayMediaSource) {
  1478.         return true;
  1479.       }
  1481.       // If we land here, both are feasible.
  1482.       goog.asserts.assert(canPlayNatively && canPlayMediaSource,
  1483.           'Both native and MSE playback should be possible!');
  1485.       // We would prefer MediaSource in some cases, and src= in others.  For
  1486.       // example, Android has native HLS, but we'd prefer our own MediaSource
  1487.       // version there.
  1488.       if (MimeUtils.isHlsType(mimeType)) {
  1489.         // Native HLS can be preferred on any platform via this flag:
  1490.         if (this.config_.streaming.preferNativeHls) {
  1491.           return true;
  1492.         }
  1494.         // For Safari, we have an older flag which only applies to this one
  1495.         // browser:
  1496.         if (Platform.isApple()) {
  1497.           return this.config_.streaming.useNativeHlsOnSafari;
  1498.         }
  1499.       }
  1501.       // In all other cases, we prefer MediaSource.
  1502.       return false;
  1503.     }
  1505.     // Unless there are good reasons to use src= (single-file playback or native
  1506.     // HLS), we prefer MediaSource.  So the final return value for choosing src=
  1507.     // is false.
  1508.     return false;
  1509.   }
  1511.   /**
  1512.    * Initializes the media source engine.
  1513.    *
  1514.    * @return {!Promise}
  1515.    * @private
  1516.    */
  1517.   async initializeMediaSourceEngineInner_() {
  1518.     goog.asserts.assert(
  1519.         shaka.util.Platform.supportsMediaSource(),
  1520.         'We should not be initializing media source on a platform that ' +
  1521.             'does not support media source.');
  1522.     goog.asserts.assert(
  1523.         this.video_,
  1524.         'We should have a media element when initializing media source.');
  1525.     goog.asserts.assert(
  1526.         this.mediaSourceEngine_ == null,
  1527.         'We should not have a media source engine yet.');
  1529.     this.makeStateChangeEvent_('media-source');
  1531.     // When changing text visibility we need to update both the text displayer
  1532.     // and streaming engine because we don't always stream text. To ensure
  1533.     // that the text displayer and streaming engine are always in sync, wait
  1534.     // until they are both initialized before setting the initial value.
  1535.     const textDisplayerFactory = this.config_.textDisplayFactory;
  1536.     const textDisplayer = textDisplayerFactory();
  1537.     this.lastTextFactory_ = textDisplayerFactory;
  1539.     const mediaSourceEngine = this.createMediaSourceEngine(
  1540.         this.video_,
  1541.         textDisplayer,
  1542.         (metadata, offset, endTime) => {
  1543.           this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
  1544.         },
  1545.         this.lcevcDec_);
  1546.     mediaSourceEngine.configure(this.config_.mediaSource);
  1547.     const {segmentRelativeVttTiming} = this.config_.manifest;
  1548.     mediaSourceEngine.setSegmentRelativeVttTiming(segmentRelativeVttTiming);
  1550.     // Wait for media source engine to finish opening. This promise should
  1551.     // NEVER be rejected as per the media source engine implementation.
  1552.     await mediaSourceEngine.open();
  1554.     // Wait until it is ready to actually store the reference.
  1555.     this.mediaSourceEngine_ = mediaSourceEngine;
  1556.   }
  1558.   /**
  1559.    * Pick an initialize a manifest parser, then have it download and parse the
  1560.    * manifest.
  1561.    *
  1562.    * @param {?string=} mimeType
  1563.    * @return {!Promise}
  1564.    * @private
  1565.    */
  1566.   async parseManifestInner_(mimeType) {
  1567.     goog.asserts.assert(
  1568.         this.assetUri_,
  1569.         'should have a uri when making the parser.');
  1570.     goog.asserts.assert(
  1571.         this.video_,
  1572.         'We should have a media element when initializing the parser.');
  1573.     goog.asserts.assert(
  1574.         this.networkingEngine_,
  1575.         'Need networking engine when initializing the parser.');
  1576.     goog.asserts.assert(
  1577.         this.cmcdManager_,
  1578.         'Need CMCD manager to populate manifest request data.');
  1579.     goog.asserts.assert(
  1580.         this.config_,
  1581.         'Need player config when initializing the parser.');
  1583.     // Store references to things we asserted so that we don't need to
  1584.     // reassert them again later.
  1585.     const networkingEngine = this.networkingEngine_;
  1587.     this.makeStateChangeEvent_('manifest-parser');
  1589.     // Create the parser that we will use to parse the manifest.
  1590.     this.parserFactory_ = shaka.media.ManifestParser.getFactory(
  1591.         this.assetUri_,
  1592.         mimeType || null);
  1593.     goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
  1594.     this.parser_ = this.parserFactory_();
  1596.     const manifestConfig =
  1597.         shaka.util.ObjectUtils.cloneObject(this.config_.manifest);
  1598.     // Don't read video segments if the player is attached to an audio element
  1599.     if (this.video_ && this.video_.nodeName === 'AUDIO') {
  1600.       manifestConfig.disableVideo = true;
  1601.     }
  1603.     this.parser_.configure(manifestConfig);
  1605.     // This will be needed by the parser once it starts parsing, so we will
  1606.     // initialize it now even through it appears a little out-of-place.
  1607.     this.regionTimeline_ =
  1608.         new shaka.media.RegionTimeline(() => this.seekRange());
  1609.     this.regionTimeline_.addEventListener('regionadd', (event) => {
  1610.       /** @type {shaka.extern.TimelineRegionInfo} */
  1611.       const region = event['region'];
  1612.       this.onRegionEvent_(
  1613.           shaka.util.FakeEvent.EventName.TimelineRegionAdded, region);
  1615.       if (this.adManager_) {
  1616.         this.adManager_.onDashTimedMetadata(region);
  1617.       }
  1618.     });
  1620.     this.qualityObserver_ = null;
  1621.     if (this.config_.streaming.observeQualityChanges) {
  1622.       this.qualityObserver_ = new shaka.media.QualityObserver(
  1623.           () => this.getBufferedInfo());
  1625.       this.qualityObserver_.addEventListener('qualitychange', (event) => {
  1626.         /** @type {shaka.extern.MediaQualityInfo} */
  1627.         const mediaQualityInfo = event['quality'];
  1628.         /** @type {number} */
  1629.         const position = event['position'];
  1630.         this.onMediaQualityChange_(mediaQualityInfo, position);
  1631.       });
  1632.     }
  1634.     const playerInterface = {
  1635.       networkingEngine: networkingEngine,
  1636.       filter: (manifest) => this.filterManifest_(manifest),
  1637.       makeTextStreamsForClosedCaptions: (manifest) => {
  1638.         return this.makeTextStreamsForClosedCaptions_(manifest);
  1639.       },
  1641.       // Called when the parser finds a timeline region. This can be called
  1642.       // before we start playback or during playback (live/in-progress
  1643.       // manifest).
  1644.       onTimelineRegionAdded: (region) => {
  1645.         this.regionTimeline_.addRegion(region);
  1646.       },
  1648.       onEvent: (event) => this.dispatchEvent(event),
  1649.       onError: (error) => this.onError_(error),
  1650.       isLowLatencyMode: () => this.isLowLatencyMode_(),
  1651.       isAutoLowLatencyMode: () => this.isAutoLowLatencyMode_(),
  1652.       enableLowLatencyMode: () => {
  1653.         this.configure('streaming.lowLatencyMode', true);
  1654.       },
  1655.       updateDuration: () => {
  1656.         if (this.streamingEngine_) {
  1657.           this.streamingEngine_.updateDuration();
  1658.         }
  1659.       },
  1660.       newDrmInfo: (stream) => {
  1661.         // We may need to create new sessions for any new init data.
  1662.         const currentDrmInfo =
  1663.             this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  1664.         // DrmEngine.newInitData() requires mediaKeys to be available.
  1665.         if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
  1666.           this.processDrmInfos_(currentDrmInfo.keySystem, stream);
  1667.         }
  1668.       },
  1669.       onManifestUpdated: () => {
  1670.         const eventName = shaka.util.FakeEvent.EventName.ManifestUpdated;
  1671.         const data = (new Map()).set('isLive', this.isLive());
  1672.         this.dispatchEvent(this.makeEvent_(eventName, data));
  1673.         if (this.adManager_) {
  1674.           this.adManager_.onManifestUpdated(this.isLive());
  1675.         }
  1676.       },
  1677.       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
  1678.     };
  1680.     const startTime = Date.now() / 1000;
  1682.     this.makeStateChangeEvent_('manifest');
  1684.     this.manifest_ = await this.parser_.start(
  1685.         this.assetUri_, playerInterface);
  1687.     // This event is fired after the manifest is parsed, but before any
  1688.     // filtering takes place.
  1689.     const event =
  1690.         this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
  1691.     this.dispatchEvent(event);
  1693.     // We require all manifests to have at least one variant.
  1694.     if (this.manifest_.variants.length == 0) {
  1695.       throw new shaka.util.Error(
  1696.           shaka.util.Error.Severity.CRITICAL,
  1697.           shaka.util.Error.Category.MANIFEST,
  1698.           shaka.util.Error.Code.NO_VARIANTS);
  1699.     }
  1701.     // Make sure that all variants are either: audio-only, video-only, or
  1702.     // audio-video.
  1703.     shaka.Player.filterForAVVariants_(this.manifest_);
  1705.     const now = Date.now() / 1000;
  1706.     const delta = now - startTime;
  1707.     this.stats_.setManifestTime(delta);
  1708.   }
  1710.   /**
  1711.    * Initializes the DRM engine.
  1712.    *
  1713.    * @return {!Promise}
  1714.    * @private
  1715.    */
  1716.   async initializeDrmInner_() {
  1717.     goog.asserts.assert(
  1718.         this.networkingEngine_,
  1719.         '|onInitializeDrm_| should never be called after |destroy|');
  1720.     goog.asserts.assert(
  1721.         this.config_,
  1722.         '|onInitializeDrm_| should never be called after |destroy|');
  1723.     goog.asserts.assert(
  1724.         this.manifest_,
  1725.         '|this.manifest_| should have been set in an earlier step.');
  1726.     goog.asserts.assert(
  1727.         this.video_,
  1728.         'We should have a media element when initializing the DRM Engine.');
  1730.     this.makeStateChangeEvent_('drm-engine');
  1732.     const startTime = Date.now() / 1000;
  1733.     let firstEvent = true;
  1735.     this.drmEngine_ = this.createDrmEngine({
  1736.       netEngine: this.networkingEngine_,
  1737.       onError: (e) => {
  1738.         this.onError_(e);
  1739.       },
  1740.       onKeyStatus: (map) => {
  1741.         this.onKeyStatus_(map);
  1742.       },
  1743.       onExpirationUpdated: (id, expiration) => {
  1744.         this.onExpirationUpdated_(id, expiration);
  1745.       },
  1746.       onEvent: (e) => {
  1747.         this.dispatchEvent(e);
  1748.         if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
  1749.             firstEvent) {
  1750.           firstEvent = false;
  1751.           const now = Date.now() / 1000;
  1752.           const delta = now - startTime;
  1753.           this.stats_.setDrmTime(delta);
  1754.           // LCEVC data by itself is not encrypted in DRM protected streams
  1755.           // and can therefore be accessed and decoded as normal. However,
  1756.           // the LCEVC decoder needs access to the VideoElement output in
  1757.           // order to apply the enhancement. In DRM contexts where the
  1758.           // browser CDM restricts access from our decoder, the enhancement
  1759.           // cannot be applied and therefore the LCEVC output canvas is
  1760.           // hidden accordingly.
  1761.           if (this.lcevcDec_) {
  1762.             this.lcevcDec_.hideCanvas();
  1763.           }
  1764.         }
  1765.       },
  1766.     });
  1768.     this.drmEngine_.configure(this.config_.drm);
  1770.     await this.drmEngine_.initForPlayback(
  1771.         this.manifest_.variants,
  1772.         this.manifest_.offlineSessionIds);
  1774.     await this.drmEngine_.attach(this.video_);
  1776.     // Now that we have drm information, filter the manifest (again) so that
  1777.     // we can ensure we only use variants with the selected key system.
  1778.     await this.filterManifest_(this.manifest_);
  1779.   }
  1781.   /**
  1782.    * Starts loading the content described by the parsed manifest.
  1783.    *
  1784.    * @param {number} startTimeOfLoad
  1785.    * @return {!Promise}
  1786.    * @private
  1787.    */
  1788.   async loadInner_(startTimeOfLoad) {
  1789.     goog.asserts.assert(
  1790.         this.video_, 'We should have a media element by now.');
  1791.     goog.asserts.assert(
  1792.         this.manifest_, 'The manifest should already be parsed.');
  1793.     goog.asserts.assert(
  1794.         this.assetUri_, 'We should have an asset uri by now.');
  1796.     this.makeStateChangeEvent_('load');
  1798.     const mediaElement = this.video_;
  1799.     this.playRateController_ = new shaka.media.PlayRateController({
  1800.       getRate: () => mediaElement.playbackRate,
  1801.       getDefaultRate: () => mediaElement.defaultPlaybackRate,
  1802.       setRate: (rate) => { mediaElement.playbackRate = rate; },
  1803.       movePlayhead: (delta) => { mediaElement.currentTime += delta; },
  1804.     });
  1806.     const updateStateHistory = () => this.updateStateHistory_();
  1807.     const onRateChange = () => this.onRateChange_();
  1808.     this.loadEventManager_.listen(
  1809.         mediaElement, 'playing', updateStateHistory);
  1810.     this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
  1811.     this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
  1812.     this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
  1814.     // Check the status of the LCEVC Dec Object. Reset, create, or close
  1815.     // depending on the config.
  1816.     this.setupLcevc_(this.config_);
  1818.     const abrFactory = this.config_.abrFactory;
  1819.     if (!this.abrManager_ || this.abrManagerFactory_ != abrFactory) {
  1820.       this.abrManagerFactory_ = abrFactory;
  1821.       this.abrManager_ = abrFactory();
  1822.       if (typeof this.abrManager_.setMediaElement != 'function') {
  1823.         shaka.Deprecate.deprecateFeature(5,
  1824.             'AbrManager',
  1825.             'Please use an AbrManager with setMediaElement function.');
  1826.         this.abrManager_.setMediaElement = () => {};
  1827.       }
  1828.       this.abrManager_.configure(this.config_.abr);
  1829.     }
  1831.     // Copy preferred languages from the config again, in case the config was
  1832.     // changed between construction and playback.
  1833.     this.currentAdaptationSetCriteria_ =
  1834.         new shaka.media.PreferenceBasedCriteria(
  1835.             this.config_.preferredAudioLanguage,
  1836.             this.config_.preferredVariantRole,
  1837.             this.config_.preferredAudioChannelCount,
  1838.             this.config_.preferredVideoHdrLevel,
  1839.             this.config_.preferredVideoLayout,
  1840.             this.config_.preferredAudioLabel,
  1841.             this.config_.mediaSource.codecSwitchingStrategy,
  1842.             this.config_.manifest.dash.enableAudioGroups);
  1844.     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
  1845.     this.currentTextRole_ = this.config_.preferredTextRole;
  1846.     this.currentTextForced_ = this.config_.preferForcedSubs;
  1848.     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
  1849.         this.config_.playRangeStart,
  1850.         this.config_.playRangeEnd);
  1852.     this.abrManager_.init((variant, clearBuffer, safeMargin) => {
  1853.       return this.switch_(variant, clearBuffer, safeMargin);
  1854.     });
  1855.     this.abrManager_.setMediaElement(mediaElement);
  1857.     // If the content is multi-codec and the browser can play more than one of
  1858.     // them, choose codecs now before we initialize streaming.
  1859.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  1860.         this.manifest_,
  1861.         this.config_.preferredVideoCodecs,
  1862.         this.config_.preferredAudioCodecs,
  1863.         this.config_.preferredDecodingAttributes);
  1865.     this.streamingEngine_ = this.createStreamingEngine();
  1866.     this.streamingEngine_.configure(this.config_.streaming);
  1868.     // Set the load mode to "loaded with media source" as late as possible so
  1869.     // that public methods won't try to access internal components until
  1870.     // they're all initialized. We MUST switch to loaded before calling
  1871.     // "streaming" so that they can access internal information.
  1872.     this.loadMode_ = shaka.Player.LoadMode.MEDIA_SOURCE;
  1874.     if (mediaElement.textTracks) {
  1875.       this.loadEventManager_.listen(
  1876.           mediaElement.textTracks, 'addtrack', (e) => {
  1877.             const trackEvent = /** @type {!TrackEvent} */(e);
  1878.             if (trackEvent.track) {
  1879.               const track = trackEvent.track;
  1880.               goog.asserts.assert(
  1881.                   track instanceof TextTrack, 'Wrong track type!');
  1883.               switch (track.kind) {
  1884.                 case 'chapters':
  1885.                   this.activateChaptersTrack_(track);
  1886.                   break;
  1887.               }
  1888.             }
  1889.           });
  1890.     }
  1892.     // The event must be fired after we filter by restrictions but before the
  1893.     // active stream is picked to allow those listening for the "streaming"
  1894.     // event to make changes before streaming starts.
  1895.     this.dispatchEvent(
  1896.         this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
  1898.     // Pick the initial streams to play.
  1899.     // Unless the user has already picked a variant, anyway, by calling
  1900.     // selectVariantTrack before this loading stage.
  1901.     let initialVariant = null;
  1902.     const activeVariant = this.streamingEngine_.getCurrentVariant();
  1903.     if (!activeVariant) {
  1904.       initialVariant = this.chooseVariant_(/* initialSelection= */ true);
  1905.       goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
  1906.     }
  1908.     // Lazy-load the stream, so we will have enough info to make the playhead.
  1909.     const createSegmentIndexPromises = [];
  1910.     const toLazyLoad = activeVariant || initialVariant;
  1911.     for (const stream of [toLazyLoad.video, toLazyLoad.audio]) {
  1912.       if (stream && !stream.segmentIndex) {
  1913.         createSegmentIndexPromises.push(stream.createSegmentIndex());
  1914.       }
  1915.     }
  1916.     if (createSegmentIndexPromises.length > 0) {
  1917.       await Promise.all(createSegmentIndexPromises);
  1918.     }
  1920.     if (this.parser_ && this.parser_.onInitialVariantChosen) {
  1921.       this.parser_.onInitialVariantChosen(toLazyLoad);
  1922.     }
  1924.     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
  1925.         this.config_.playRangeStart,
  1926.         this.config_.playRangeEnd);
  1928.     this.playhead_ = this.createPlayhead(this.startTime_);
  1929.     this.playheadObservers_ =
  1930.         this.createPlayheadObserversForMSE_(startTimeOfLoad);
  1932.     // We need to start the buffer management code near the end because it
  1933.     // will set the initial buffering state and that depends on other
  1934.     // components being initialized.
  1935.     const rebufferThreshold = Math.max(
  1936.         this.manifest_.minBufferTime, this.config_.streaming.rebufferingGoal);
  1937.     this.startBufferManagement_(mediaElement, rebufferThreshold);
  1939.     // Now we can switch to the initial variant.
  1940.     if (!activeVariant) {
  1941.       goog.asserts.assert(initialVariant,
  1942.           'Must have choosen an initial variant!');
  1944.       this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
  1945.           /* clearBuffer= */ false, /* safeMargin= */ 0);
  1947.       // Now that we have initial streams, we may adjust the start time to
  1948.       // align to a segment boundary.
  1949.       if (this.config_.streaming.startAtSegmentBoundary) {
  1950.         this.playhead_.setStartTime(await this.adjustStartTime_(
  1951.             initialVariant, this.playhead_.getTime()));
  1952.       }
  1953.     }
  1955.     this.playhead_.ready();
  1957.     // Decide if text should be shown automatically.
  1958.     // similar to video/audio track, we would skip switch initial text track
  1959.     // if user already pick text track (via selectTextTrack api)
  1960.     const activeTextTrack = this.getTextTracks().find((t) => t.active);
  1962.     if (!activeTextTrack) {
  1963.       const initialTextStream = this.chooseTextStream_();
  1965.       if (initialTextStream) {
  1966.         this.addTextStreamToSwitchHistory_(
  1967.             initialTextStream, /* fromAdaptation= */ true);
  1968.       }
  1970.       if (initialVariant) {
  1971.         this.setInitialTextState_(initialVariant, initialTextStream);
  1972.       }
  1974.       // Don't initialize with a text stream unless we should be streaming
  1975.       // text.
  1976.       if (initialTextStream && this.shouldStreamText_()) {
  1977.         this.streamingEngine_.switchTextStream(initialTextStream);
  1978.       }
  1979.     }
  1982.     // Start streaming content. This will start the flow of content down to
  1983.     // media source.
  1984.     await this.streamingEngine_.start();
  1986.     if (this.config_.abr.enabled) {
  1987.       this.abrManager_.enable();
  1988.       this.onAbrStatusChanged_();
  1989.     }
  1991.     // Dispatch a 'trackschanged' event now that all initial filtering is
  1992.     // done.
  1993.     this.onTracksChanged_();
  1995.     // Now that we've filtered out variants that aren't compatible with the
  1996.     // active one, update abr manager with filtered variants.
  1997.     // NOTE: This may be unnecessary.  We've already chosen one codec in
  1998.     // chooseCodecsAndFilterManifest_ before we started streaming.  But it
  1999.     // doesn't hurt, and this will all change when we start using
  2000.     // MediaCapabilities and codec switching.
  2001.     // TODO(#1391): Re-evaluate with MediaCapabilities and codec switching.
  2002.     this.updateAbrManagerVariants_();
  2004.     const hasPrimary = this.manifest_.variants.some((v) => v.primary);
  2005.     if (!this.config_.preferredAudioLanguage && !hasPrimary) {
  2006.       shaka.log.warning('No preferred audio language set.  ' +
  2007.           'We have chosen an arbitrary language initially');
  2008.     }
  2010.     const isLive = this.isLive();
  2012.     if (isLive && (this.config_.streaming.liveSync ||
  2013.         this.manifest_.serviceDescription)) {
  2014.       const onTimeUpdate = () => this.onTimeUpdate_();
  2015.       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
  2016.     } else if (!isLive) {
  2017.       const onVideoProgress = () => this.onVideoProgress_();
  2018.       this.loadEventManager_.listen(
  2019.           mediaElement, 'timeupdate', onVideoProgress);
  2020.       this.onVideoProgress_();
  2021.     }
  2023.     if (this.adManager_) {
  2024.       this.adManager_.onManifestUpdated(isLive);
  2025.     }
  2027.     this.fullyLoaded_ = true;
  2029.     // Wait for the 'loadedmetadata' event to measure load() latency.
  2030.     this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
  2031.       const now = Date.now() / 1000;
  2032.       const delta = now - startTimeOfLoad;
  2033.       this.stats_.setLoadLatency(delta);
  2034.     });
  2035.   }
  2037.   /**
  2038.    * Initializes the DRM engine for use by src equals.
  2039.    *
  2040.    * @param {string} mimeType
  2041.    * @return {!Promise}
  2042.    * @private
  2043.    */
  2044.   async initializeSrcEqualsDrmInner_(mimeType) {
  2045.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2047.     goog.asserts.assert(
  2048.         this.networkingEngine_,
  2049.         '|onInitializeSrcEqualsDrm_| should never be called after |destroy|');
  2050.     goog.asserts.assert(
  2051.         this.config_,
  2052.         '|onInitializeSrcEqualsDrm_| should never be called after |destroy|');
  2054.     const startTime = Date.now() / 1000;
  2055.     let firstEvent = true;
  2057.     this.drmEngine_ = this.createDrmEngine({
  2058.       netEngine: this.networkingEngine_,
  2059.       onError: (e) => {
  2060.         this.onError_(e);
  2061.       },
  2062.       onKeyStatus: (map) => {
  2063.         this.onKeyStatus_(map);
  2064.       },
  2065.       onExpirationUpdated: (id, expiration) => {
  2066.         this.onExpirationUpdated_(id, expiration);
  2067.       },
  2068.       onEvent: (e) => {
  2069.         this.dispatchEvent(e);
  2070.         if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
  2071.             firstEvent) {
  2072.           firstEvent = false;
  2073.           const now = Date.now() / 1000;
  2074.           const delta = now - startTime;
  2075.           this.stats_.setDrmTime(delta);
  2076.         }
  2077.       },
  2078.     });
  2080.     this.drmEngine_.configure(this.config_.drm);
  2082.     // TODO: Instead of feeding DrmEngine with Variants, we should refactor
  2083.     // DrmEngine so that it takes a minimal config derived from Variants.  In
  2084.     // cases like this one or in removal of stored content, the details are
  2085.     // largely unimportant.  We should have a saner way to initialize
  2086.     // DrmEngine.
  2087.     // That would also insulate DrmEngine from manifest changes in the future.
  2088.     // For now, that is time-consuming and this synthetic Variant is easy, so
  2089.     // I'm putting it off.  Since this is only expected to be used for native
  2090.     // HLS in Safari, this should be safe. -JCP
  2091.     /** @type {shaka.extern.Variant} */
  2092.     const variant = {
  2093.       id: 0,
  2094.       language: 'und',
  2095.       disabledUntilTime: 0,
  2096.       primary: false,
  2097.       audio: null,
  2098.       video: {
  2099.         id: 0,
  2100.         originalId: null,
  2101.         groupId: null,
  2102.         createSegmentIndex: () => Promise.resolve(),
  2103.         segmentIndex: null,
  2104.         mimeType: mimeType ? shaka.util.MimeUtils.getBasicType(mimeType) : '',
  2105.         codecs: mimeType ? shaka.util.MimeUtils.getCodecs(mimeType) : '',
  2106.         encrypted: true,
  2107.         drmInfos: [],  // Filled in by DrmEngine config.
  2108.         keyIds: new Set(),
  2109.         language: 'und',
  2110.         originalLanguage: null,
  2111.         label: null,
  2112.         type: ContentType.VIDEO,
  2113.         primary: false,
  2114.         trickModeVideo: null,
  2115.         emsgSchemeIdUris: null,
  2116.         roles: [],
  2117.         forced: false,
  2118.         channelsCount: null,
  2119.         audioSamplingRate: null,
  2120.         spatialAudio: false,
  2121.         closedCaptions: null,
  2122.         accessibilityPurpose: null,
  2123.         external: false,
  2124.         fastSwitching: false,
  2125.       },
  2126.       bandwidth: 100,
  2127.       allowedByApplication: true,
  2128.       allowedByKeySystem: true,
  2129.       decodingInfos: [],
  2130.     };
  2132.     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
  2133.     await this.drmEngine_.initForPlayback(
  2134.         [variant], /* offlineSessionIds= */ []);
  2135.     await this.drmEngine_.attach(this.video_);
  2136.   }
  2138.   /**
  2139.    * Passes the asset URI along to the media element, so it can be played src
  2140.    * equals style.
  2141.    *
  2142.    * @param {number} startTimeOfLoad
  2143.    * @param {string} mimeType
  2144.    * @return {!Promise}
  2145.    *
  2146.    * @private
  2147.    */
  2148.   async srcEqualsInner_(startTimeOfLoad, mimeType) {
  2149.     this.makeStateChangeEvent_('src-equals');
  2151.     goog.asserts.assert(
  2152.         this.video_, 'We should have a media element when loading.');
  2153.     goog.asserts.assert(
  2154.         this.assetUri_, 'We should have a valid uri when loading.');
  2156.     const mediaElement = this.video_;
  2158.     this.playhead_ = new shaka.media.SrcEqualsPlayhead(mediaElement);
  2160.     // This flag is used below in the language preference setup to check if
  2161.     // this load was canceled before the necessary awaits completed.
  2162.     let unloaded = false;
  2163.     this.cleanupOnUnload_.push(() => {
  2164.       unloaded = true;
  2165.     });
  2167.     if (this.startTime_ != null) {
  2168.       this.playhead_.setStartTime(this.startTime_);
  2169.     }
  2171.     this.playRateController_ = new shaka.media.PlayRateController({
  2172.       getRate: () => mediaElement.playbackRate,
  2173.       getDefaultRate: () => mediaElement.defaultPlaybackRate,
  2174.       setRate: (rate) => { mediaElement.playbackRate = rate; },
  2175.       movePlayhead: (delta) => { mediaElement.currentTime += delta; },
  2176.     });
  2178.     // We need to start the buffer management code near the end because it
  2179.     // will set the initial buffering state and that depends on other
  2180.     // components being initialized.
  2181.     const rebufferThreshold = this.config_.streaming.rebufferingGoal;
  2182.     this.startBufferManagement_(mediaElement, rebufferThreshold);
  2184.     // Add all media element listeners.
  2185.     const updateStateHistory = () => this.updateStateHistory_();
  2186.     const onRateChange = () => this.onRateChange_();
  2187.     this.loadEventManager_.listen(
  2188.         mediaElement, 'playing', updateStateHistory);
  2189.     this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
  2190.     this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
  2191.     this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
  2193.     // Wait for the 'loadedmetadata' event to measure load() latency, but only
  2194.     // if preload is set in a way that would result in this event firing
  2195.     // automatically.
  2196.     // See https://github.com/shaka-project/shaka-player/issues/2483
  2197.     if (mediaElement.preload != 'none') {
  2198.       this.loadEventManager_.listenOnce(
  2199.           mediaElement, 'loadedmetadata', () => {
  2200.             const now = Date.now() / 1000;
  2201.             const delta = now - startTimeOfLoad;
  2202.             this.stats_.setLoadLatency(delta);
  2203.           });
  2204.     }
  2206.     // The audio tracks are only available on Safari at the moment, but this
  2207.     // drives the tracks API for Safari's native HLS. So when they change,
  2208.     // fire the corresponding Shaka Player event.
  2209.     if (mediaElement.audioTracks) {
  2210.       this.loadEventManager_.listen(mediaElement.audioTracks, 'addtrack',
  2211.           () => this.onTracksChanged_());
  2212.       this.loadEventManager_.listen(mediaElement.audioTracks, 'removetrack',
  2213.           () => this.onTracksChanged_());
  2214.       this.loadEventManager_.listen(mediaElement.audioTracks, 'change',
  2215.           () => this.onTracksChanged_());
  2216.     }
  2218.     if (mediaElement.textTracks) {
  2219.       this.loadEventManager_.listen(
  2220.           mediaElement.textTracks, 'addtrack', (e) => {
  2221.             const trackEvent = /** @type {!TrackEvent} */(e);
  2222.             if (trackEvent.track) {
  2223.               const track = trackEvent.track;
  2224.               goog.asserts.assert(
  2225.                   track instanceof TextTrack, 'Wrong track type!');
  2227.               switch (track.kind) {
  2228.                 case 'metadata':
  2229.                   this.processTimedMetadataSrcEqls_(track);
  2230.                   break;
  2232.                 case 'chapters':
  2233.                   this.activateChaptersTrack_(track);
  2234.                   break;
  2236.                 default:
  2237.                   this.onTracksChanged_();
  2238.                   break;
  2239.               }
  2240.             }
  2241.           });
  2243.       this.loadEventManager_.listen(
  2244.           mediaElement.textTracks, 'removetrack',
  2245.           () => this.onTracksChanged_());
  2246.       this.loadEventManager_.listen(
  2247.           mediaElement.textTracks, 'change',
  2248.           () => this.onTracksChanged_());
  2249.     }
  2251.     // By setting |src| we are done "loading" with src=. We don't need to set
  2252.     // the current time because |playhead| will do that for us.
  2253.     mediaElement.src = this.cmcdManager_.appendSrcData(
  2254.         this.assetUri_, mimeType);
  2256.     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
  2257.     // no matter the value of the preload attribute.  This is harmful on some
  2258.     // other platforms by triggering unbounded loading of media data, but is
  2259.     // necessary here.
  2260.     if (shaka.util.Platform.isTizen() || shaka.util.Platform.isWebOS()) {
  2261.       mediaElement.load();
  2262.     }
  2264.     // Set the load mode last so that we know that all our components are
  2265.     // initialized.
  2266.     this.loadMode_ = shaka.Player.LoadMode.SRC_EQUALS;
  2268.     // The event doesn't mean as much for src= playback, since we don't
  2269.     // control streaming.  But we should fire it in this path anyway since
  2270.     // some applications may be expecting it as a life-cycle event.
  2271.     this.dispatchEvent(
  2272.         this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
  2274.     // The "load" Promise is resolved when we have loaded the metadata.  If we
  2275.     // wait for the full data, that won't happen on Safari until the play
  2276.     // button is hit.
  2277.     const fullyLoaded = new shaka.util.PublicPromise();
  2278.     shaka.util.MediaReadyState.waitForReadyState(mediaElement,
  2279.         HTMLMediaElement.HAVE_METADATA,
  2280.         this.loadEventManager_,
  2281.         () => {
  2282.           this.playhead_.ready();
  2283.           fullyLoaded.resolve();
  2284.         });
  2286.     // We can't switch to preferred languages, though, until the data is
  2287.     // loaded.
  2288.     shaka.util.MediaReadyState.waitForReadyState(mediaElement,
  2289.         HTMLMediaElement.HAVE_CURRENT_DATA,
  2290.         this.loadEventManager_,
  2291.         async () => {
  2292.           this.setupPreferredAudioOnSrc_();
  2294.           // Applying the text preference too soon can result in it being
  2295.           // reverted.  Wait for native HLS to pick something first.
  2296.           const textTracks = this.getFilteredTextTracks_();
  2297.           if (!textTracks.find((t) => t.mode != 'disabled')) {
  2298.             await new Promise((resolve) => {
  2299.               this.loadEventManager_.listenOnce(
  2300.                   mediaElement.textTracks, 'change', resolve);
  2302.               // We expect the event to fire because it does on Safari.
  2303.               // But in case it doesn't on some other platform or future
  2304.               // version, move on in 1 second no matter what.  This keeps the
  2305.               // language settings from being completely ignored if something
  2306.               // goes wrong.
  2307.               new shaka.util.Timer(resolve).tickAfter(1);
  2308.             });
  2309.           } else if (textTracks.length > 0) {
  2310.             this.isTextVisible_ = true;
  2311.           }
  2313.           // If we have moved on to another piece of content while waiting for
  2314.           // the above event/timer, we should not change tracks here.
  2315.           if (unloaded) {
  2316.             return;
  2317.           }
  2319.           this.setupPreferredTextOnSrc_();
  2320.         });
  2322.     if (mediaElement.error) {
  2323.       // Already failed!
  2324.       fullyLoaded.reject(this.videoErrorToShakaError_());
  2325.     } else if (mediaElement.preload == 'none') {
  2326.       shaka.log.alwaysWarn(
  2327.           'With <video preload="none">, the browser will not load anything ' +
  2328.           'until play() is called. We are unable to measure load latency ' +
  2329.           'in a meaningful way, and we cannot provide track info yet. ' +
  2330.           'Please do not use preload="none" with Shaka Player.');
  2331.       // We can't wait for an event load loadedmetadata, since that will be
  2332.       // blocked until a user interaction.  So resolve the Promise now.
  2333.       fullyLoaded.resolve();
  2334.     }
  2336.     this.loadEventManager_.listenOnce(mediaElement, 'error', () => {
  2337.       fullyLoaded.reject(this.videoErrorToShakaError_());
  2338.     });
  2340.     await fullyLoaded;
  2342.     const isLive = this.isLive();
  2344.     if (isLive && this.config_.streaming.liveSync) {
  2345.       const onTimeUpdate = () => this.onTimeUpdate_();
  2346.       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
  2347.     } else if (!isLive) {
  2348.       const onVideoProgress = () => this.onVideoProgress_();
  2349.       this.loadEventManager_.listen(
  2350.           mediaElement, 'timeupdate', onVideoProgress);
  2351.       this.onVideoProgress_();
  2352.     }
  2354.     if (this.adManager_) {
  2355.       this.adManager_.onManifestUpdated(isLive);
  2356.       // There is no good way to detect when the manifest has been updated,
  2357.       // so we use seekRange().end so we can tell when it has been updated.
  2358.       if (isLive) {
  2359.         let prevSeekRangeEnd = this.seekRange().end;
  2360.         this.loadEventManager_.listen(mediaElement, 'progress', () => {
  2361.           const newSeekRangeEnd = this.seekRange().end;
  2362.           if (prevSeekRangeEnd != newSeekRangeEnd) {
  2363.             this.adManager_.onManifestUpdated(this.isLive());
  2364.             prevSeekRangeEnd = newSeekRangeEnd;
  2365.           }
  2366.         });
  2367.       }
  2368.     }
  2370.     this.fullyLoaded_ = true;
  2371.   }
  2373.   /**
  2374.    * This method setup the preferred audio using src=..
  2375.    *
  2376.    * @private
  2377.    */
  2378.   setupPreferredAudioOnSrc_() {
  2379.     const preferredAudioLanguage = this.config_.preferredAudioLanguage;
  2381.     // If the user has not selected a preference, the browser preference is
  2382.     // left.
  2383.     if (preferredAudioLanguage == '') {
  2384.       return;
  2385.     }
  2387.     const preferredVariantRole = this.config_.preferredVariantRole;
  2388.     this.selectAudioLanguage(preferredAudioLanguage, preferredVariantRole);
  2389.   }
  2391.   /**
  2392.    * This method setup the preferred text using src=.
  2393.    *
  2394.    * @private
  2395.    */
  2396.   setupPreferredTextOnSrc_() {
  2397.     const preferredTextLanguage = this.config_.preferredTextLanguage;
  2399.     // If the user has not selected a preference, the browser preference is
  2400.     // left.
  2401.     if (preferredTextLanguage == '') {
  2402.       return;
  2403.     }
  2405.     const preferForcedSubs = this.config_.preferForcedSubs;
  2406.     const preferredTextRole = this.config_.preferredTextRole;
  2408.     this.selectTextLanguage(preferredTextLanguage, preferredTextRole,
  2409.         preferForcedSubs);
  2410.   }
  2412.   /**
  2413.    * We're looking for metadata tracks to process id3 tags. One of the uses is
  2414.    * for ad info on LIVE streams
  2415.    *
  2416.    * @param {!TextTrack} track
  2417.    * @private
  2418.    */
  2419.   processTimedMetadataSrcEqls_(track) {
  2420.     if (track.kind != 'metadata') {
  2421.       return;
  2422.     }
  2424.     // Hidden mode is required for the cuechange event to launch correctly
  2425.     track.mode = 'hidden';
  2426.     this.loadEventManager_.listen(track, 'cuechange', () => {
  2427.       if (!track.activeCues) {
  2428.         return;
  2429.       }
  2431.       for (const cue of track.activeCues) {
  2432.         this.dispatchMetadataEvent_(cue.startTime, cue.endTime,
  2433.             cue.type, cue.value);
  2435.         if (this.adManager_) {
  2436.           this.adManager_.onCueMetadataChange(cue.value);
  2437.         }
  2438.       }
  2439.     });
  2441.     // In Safari the initial assignment does not always work, so we schedule
  2442.     // this process to be repeated several times to ensure that it has been put
  2443.     // in the correct mode.
  2444.     const timer = new shaka.util.Timer(() => {
  2445.       const textTracks = this.getMetadataTracks_();
  2446.       for (const textTrack of textTracks) {
  2447.         textTrack.mode = 'hidden';
  2448.       }
  2449.     }).tickNow().tickAfter(0.5);
  2451.     this.cleanupOnUnload_.push(() => {
  2452.       timer.stop();
  2453.     });
  2454.   }
  2457.   /**
  2458.    * @param {!Array.<shaka.extern.ID3Metadata>} metadata
  2459.    * @param {number} offset
  2460.    * @param {?number} segmentEndTime
  2461.    * @private
  2462.    */
  2463.   processTimedMetadataMediaSrc_(metadata, offset, segmentEndTime) {
  2464.     for (const sample of metadata) {
  2465.       if (sample.data && sample.cueTime && sample.frames) {
  2466.         const start = sample.cueTime + offset;
  2467.         let end = segmentEndTime;
  2468.         // This can happen when the ID3 info arrives in a previous segment.
  2469.         if (end && start > end) {
  2470.           end = start;
  2471.         }
  2472.         const metadataType = 'org.id3';
  2473.         for (const frame of sample.frames) {
  2474.           const payload = frame;
  2475.           this.dispatchMetadataEvent_(start, end, metadataType, payload);
  2476.         }
  2478.         if (this.adManager_) {
  2479.           this.adManager_.onHlsTimedMetadata(sample, start);
  2480.         }
  2481.       }
  2482.     }
  2483.   }
  2486.   /**
  2487.    * Construct and fire a Player.Metadata event
  2488.    *
  2489.    * @param {number} startTime
  2490.    * @param {?number} endTime
  2491.    * @param {string} metadataType
  2492.    * @param {shaka.extern.MetadataFrame} payload
  2493.    * @private
  2494.    */
  2495.   dispatchMetadataEvent_(startTime, endTime, metadataType, payload) {
  2496.     goog.asserts.assert(!endTime || startTime <= endTime,
  2497.         'Metadata start time should be less or equal to the end time!');
  2498.     const eventName = shaka.util.FakeEvent.EventName.Metadata;
  2499.     const data = new Map()
  2500.         .set('startTime', startTime)
  2501.         .set('endTime', endTime)
  2502.         .set('metadataType', metadataType)
  2503.         .set('payload', payload);
  2504.     this.dispatchEvent(this.makeEvent_(eventName, data));
  2505.   }
  2507.   /**
  2508.    * Set the mode on a chapters track so that it loads.
  2509.    *
  2510.    * @param {?TextTrack} track
  2511.    * @private
  2512.    */
  2513.   activateChaptersTrack_(track) {
  2514.     if (!track || track.kind != 'chapters') {
  2515.       return;
  2516.     }
  2518.     // Hidden mode is required for the cuechange event to launch correctly and
  2519.     // get the cues and the activeCues
  2520.     track.mode = 'hidden';
  2522.     // In Safari the initial assignment does not always work, so we schedule
  2523.     // this process to be repeated several times to ensure that it has been put
  2524.     // in the correct mode.
  2525.     const timer = new shaka.util.Timer(() => {
  2526.       track.mode = 'hidden';
  2527.     }).tickNow().tickAfter(0.5);
  2529.     this.cleanupOnUnload_.push(() => {
  2530.       timer.stop();
  2531.     });
  2532.   }
  2534.   /**
  2535.    * Take a series of variants and ensure that they only contain one type of
  2536.    * variant. The different options are:
  2537.    *  1. Audio-Video
  2538.    *  2. Audio-Only
  2539.    *  3. Video-Only
  2540.    *
  2541.    * A manifest can only contain a single type because once we initialize media
  2542.    * source to expect specific streams, it must always have content for those
  2543.    * streams. If we were to start with audio+video and switch to an audio-only
  2544.    * variant, media source would block waiting for video content.
  2545.    *
  2546.    * @param {shaka.extern.Manifest} manifest
  2547.    * @private
  2548.    */
  2549.   static filterForAVVariants_(manifest) {
  2550.     const isAVVariant = (variant) => {
  2551.       // Audio-video variants may include both streams separately or may be
  2552.       // single multiplexed streams with multiple codecs.
  2553.       return (variant.video && variant.audio) ||
  2554.              (variant.video && variant.video.codecs.includes(','));
  2555.     };
  2556.     if (manifest.variants.some(isAVVariant)) {
  2557.       shaka.log.debug('Found variant with audio and video content, ' +
  2558.           'so filtering out audio-only content.');
  2559.       manifest.variants = manifest.variants.filter(isAVVariant);
  2560.     }
  2561.   }
  2563.   /**
  2564.    * Releases all of the mutexes of the player. Meant for use by the tests.
  2565.    * @export
  2566.    */
  2567.   releaseAllMutexes() {
  2568.     this.mutex_.releaseAll();
  2569.   }
  2571.   /**
  2572.    * Create a new DrmEngine instance. This may be replaced by tests to create
  2573.    * fake instances. Configuration and initialization will be handled after
  2574.    * |createDrmEngine|.
  2575.    *
  2576.    * @param {shaka.media.DrmEngine.PlayerInterface} playerInterface
  2577.    * @return {!shaka.media.DrmEngine}
  2578.    */
  2579.   createDrmEngine(playerInterface) {
  2580.     const updateExpirationTime = this.config_.drm.updateExpirationTime;
  2581.     return new shaka.media.DrmEngine(playerInterface, updateExpirationTime);
  2582.   }
  2584.   /**
  2585.    * Creates a new instance of NetworkingEngine.  This can be replaced by tests
  2586.    * to create fake instances instead.
  2587.    *
  2588.    * @return {!shaka.net.NetworkingEngine}
  2589.    */
  2590.   createNetworkingEngine() {
  2591.     /** @type {function(number, number, boolean)} */
  2592.     const onProgressUpdated_ = (deltaTimeMs, bytesDownloaded, allowSwitch) => {
  2593.       // In some situations, such as during offline storage, the abr manager
  2594.       // might not yet exist. Therefore, we need to check if abr manager has
  2595.       // been initialized before using it.
  2596.       if (this.abrManager_) {
  2597.         this.abrManager_.segmentDownloaded(
  2598.             deltaTimeMs, bytesDownloaded, allowSwitch);
  2599.       }
  2600.     };
  2601.     /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
  2602.     const onHeadersReceived_ = (headers, request, requestType) => {
  2603.       // Release a 'downloadheadersreceived' event.
  2604.       const name = shaka.util.FakeEvent.EventName.DownloadHeadersReceived;
  2605.       const data = new Map()
  2606.           .set('headers', headers)
  2607.           .set('request', request)
  2608.           .set('requestType', requestType);
  2609.       this.dispatchEvent(this.makeEvent_(name, data));
  2610.     };
  2611.     /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
  2612.     const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
  2613.       // Release a 'downloadfailed' event.
  2614.       const name = shaka.util.FakeEvent.EventName.DownloadFailed;
  2615.       const data = new Map()
  2616.           .set('request', request)
  2617.           .set('error', error)
  2618.           .set('httpResponseCode', httpResponseCode)
  2619.           .set('aborted', aborted);
  2620.       this.dispatchEvent(this.makeEvent_(name, data));
  2621.     };
  2622.     /** @type {shaka.net.NetworkingEngine.OnRequest} */
  2623.     const onRequest_ = (type, request, context) => {
  2624.       this.cmcdManager_.applyData(type, request, context);
  2625.     };
  2628.     const onRetry_ = (type, context, newUrl, oldUrl) => {
  2629.       if (this.parser_ && this.parser_.banLocation) {
  2630.         this.parser_.banLocation(oldUrl);
  2631.       }
  2632.     };
  2634.     return new shaka.net.NetworkingEngine(
  2635.         onProgressUpdated_, onHeadersReceived_, onDownloadFailed_, onRequest_,
  2636.         onRetry_);
  2637.   }
  2639.   /**
  2640.    * Creates a new instance of Playhead.  This can be replaced by tests to
  2641.    * create fake instances instead.
  2642.    *
  2643.    * @param {?number} startTime
  2644.    * @return {!shaka.media.Playhead}
  2645.    */
  2646.   createPlayhead(startTime) {
  2647.     goog.asserts.assert(this.manifest_, 'Must have manifest');
  2648.     goog.asserts.assert(this.video_, 'Must have video');
  2649.     return new shaka.media.MediaSourcePlayhead(
  2650.         this.video_,
  2651.         this.manifest_,
  2652.         this.config_.streaming,
  2653.         startTime,
  2654.         () => this.onSeek_(),
  2655.         (event) => this.dispatchEvent(event));
  2656.   }
  2658.   /**
  2659.    * Create the observers for MSE playback. These observers are responsible for
  2660.    * notifying the app and player of specific events during MSE playback.
  2661.    *
  2662.    * @param {number} startTimeOfLoad
  2663.    * @return {!shaka.media.PlayheadObserverManager}
  2664.    * @private
  2665.    */
  2666.   createPlayheadObserversForMSE_(startTimeOfLoad) {
  2667.     goog.asserts.assert(this.manifest_, 'Must have manifest');
  2668.     goog.asserts.assert(this.regionTimeline_, 'Must have region timeline');
  2669.     goog.asserts.assert(this.video_, 'Must have video element');
  2671.     const startsPastZero = this.isLive() || startTimeOfLoad > 0;
  2673.     // Create the region observer. This will allow us to notify the app when we
  2674.     // move in and out of timeline regions.
  2675.     const regionObserver = new shaka.media.RegionObserver(
  2676.         this.regionTimeline_, startsPastZero);
  2678.     regionObserver.addEventListener('enter', (event) => {
  2679.       /** @type {shaka.extern.TimelineRegionInfo} */
  2680.       const region = event['region'];
  2681.       this.onRegionEvent_(
  2682.           shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
  2683.     });
  2685.     regionObserver.addEventListener('exit', (event) => {
  2686.       /** @type {shaka.extern.TimelineRegionInfo} */
  2687.       const region = event['region'];
  2688.       this.onRegionEvent_(
  2689.           shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
  2690.     });
  2692.     regionObserver.addEventListener('skip', (event) => {
  2693.       /** @type {shaka.extern.TimelineRegionInfo} */
  2694.       const region = event['region'];
  2695.       /** @type {boolean} */
  2696.       const seeking = event['seeking'];
  2697.       // If we are seeking, we don't want to surface the enter/exit events since
  2698.       // they didn't play through them.
  2699.       if (!seeking) {
  2700.         this.onRegionEvent_(
  2701.             shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
  2702.         this.onRegionEvent_(
  2703.             shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
  2704.       }
  2705.     });
  2707.     // Now that we have all our observers, create a manager for them.
  2708.     const manager = new shaka.media.PlayheadObserverManager(this.video_);
  2709.     manager.manage(regionObserver);
  2710.     if (this.qualityObserver_) {
  2711.       manager.manage(this.qualityObserver_);
  2712.     }
  2713.     return manager;
  2714.   }
  2716.   /**
  2717.    * Initialize and start the buffering system (observer and timer) so that we
  2718.    * can monitor our buffer lead during playback.
  2719.    *
  2720.    * @param {!HTMLMediaElement} mediaElement
  2721.    * @param {number} rebufferingGoal
  2722.    * @private
  2723.    */
  2724.   startBufferManagement_(mediaElement, rebufferingGoal) {
  2725.     goog.asserts.assert(
  2726.         !this.bufferObserver_,
  2727.         'No buffering observer should exist before initialization.');
  2729.     // Give dummy values, will be updated below.
  2730.     this.bufferObserver_ = new shaka.media.BufferingObserver(1, 2);
  2732.     // Force us back to a buffering state. This ensure everything is starting in
  2733.     // the same state.
  2734.     this.bufferObserver_.setState(shaka.media.BufferingObserver.State.STARVING);
  2735.     this.updateBufferingSettings_(rebufferingGoal);
  2736.     this.updateBufferState_();
  2738.     this.loadEventManager_.listen(mediaElement, 'waiting',
  2739.         (e) => this.pollBufferState_());
  2740.     this.loadEventManager_.listen(mediaElement, 'stalled',
  2741.         (e) => this.pollBufferState_());
  2742.     this.loadEventManager_.listen(mediaElement, 'canplaythrough',
  2743.         (e) => this.pollBufferState_());
  2744.     this.loadEventManager_.listen(mediaElement, 'progress',
  2745.         (e) => this.pollBufferState_());
  2746.   }
  2748.   /**
  2749.    * Updates the buffering thresholds based on the new rebuffering goal.
  2750.    *
  2751.    * @param {number} rebufferingGoal
  2752.    * @private
  2753.    */
  2754.   updateBufferingSettings_(rebufferingGoal) {
  2755.     // The threshold to transition back to satisfied when starving.
  2756.     const starvingThreshold = rebufferingGoal;
  2757.     // The threshold to transition into starving when satisfied.
  2758.     // We use a "typical" threshold, unless the rebufferingGoal is unusually
  2759.     // low.
  2760.     // Then we force the value down to half the rebufferingGoal, since
  2761.     // starvingThreshold must be strictly larger than satisfiedThreshold for the
  2762.     // logic in BufferingObserver to work correctly.
  2763.     const satisfiedThreshold = Math.min(
  2764.         shaka.Player.TYPICAL_BUFFERING_THRESHOLD_, rebufferingGoal / 2);
  2766.     this.bufferObserver_.setThresholds(starvingThreshold, satisfiedThreshold);
  2767.   }
  2769.   /**
  2770.    * This method is called periodically to check what the buffering observer
  2771.    * says so that we can update the rest of the buffering behaviours.
  2772.    *
  2773.    * @private
  2774.    */
  2775.   pollBufferState_() {
  2776.     goog.asserts.assert(
  2777.         this.video_,
  2778.         'Need a media element to update the buffering observer');
  2780.     goog.asserts.assert(
  2781.         this.bufferObserver_,
  2782.         'Need a buffering observer to update');
  2784.     let bufferedToEnd;
  2785.     switch (this.loadMode_) {
  2786.       case shaka.Player.LoadMode.SRC_EQUALS:
  2787.         bufferedToEnd = this.isBufferedToEndSrc_();
  2788.         break;
  2789.       case shaka.Player.LoadMode.MEDIA_SOURCE:
  2790.         bufferedToEnd = this.isBufferedToEndMS_();
  2791.         break;
  2792.       default:
  2793.         bufferedToEnd = false;
  2794.         break;
  2795.     }
  2797.     const bufferLead = shaka.media.TimeRangesUtils.bufferedAheadOf(
  2798.         this.video_.buffered,
  2799.         this.video_.currentTime);
  2801.     const stateChanged = this.bufferObserver_.update(bufferLead, bufferedToEnd);
  2803.     // If the state changed, we need to surface the event.
  2804.     if (stateChanged) {
  2805.       this.updateBufferState_();
  2806.     }
  2807.   }
  2809.   /**
  2810.    * Create a new media source engine. This will ONLY be replaced by tests as a
  2811.    * way to inject fake media source engine instances.
  2812.    *
  2813.    * @param {!HTMLMediaElement} mediaElement
  2814.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  2815.    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)}
  2816.    *  onMetadata
  2817.    * @param {shaka.lcevc.Dec} lcevcDec
  2818.    *
  2819.    * @return {!shaka.media.MediaSourceEngine}
  2820.    */
  2821.   createMediaSourceEngine(mediaElement, textDisplayer, onMetadata, lcevcDec) {
  2822.     return new shaka.media.MediaSourceEngine(
  2823.         mediaElement,
  2824.         textDisplayer,
  2825.         onMetadata,
  2826.         lcevcDec);
  2827.   }
  2829.   /**
  2830.    * Create a new CMCD manager.
  2831.    *
  2832.    * @private
  2833.    */
  2834.   createCmcd_() {
  2835.     /** @type {shaka.util.CmcdManager.PlayerInterface} */
  2836.     const playerInterface = {
  2837.       getBandwidthEstimate: () => this.abrManager_ ?
  2838.         this.abrManager_.getBandwidthEstimate() : NaN,
  2839.       getBufferedInfo: () => this.getBufferedInfo(),
  2840.       getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
  2841.       getPlaybackRate: () => this.getPlaybackRate(),
  2842.       getNetworkingEngine: () => this.getNetworkingEngine(),
  2843.       getVariantTracks: () => this.getVariantTracks(),
  2844.       isLive: () => this.isLive(),
  2845.     };
  2847.     return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
  2848.   }
  2850.   /**
  2851.    * Creates a new instance of StreamingEngine.  This can be replaced by tests
  2852.    * to create fake instances instead.
  2853.    *
  2854.    * @return {!shaka.media.StreamingEngine}
  2855.    */
  2856.   createStreamingEngine() {
  2857.     goog.asserts.assert(
  2858.         this.abrManager_ && this.mediaSourceEngine_ && this.manifest_,
  2859.         'Must not be destroyed');
  2861.     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
  2862.     const playerInterface = {
  2863.       getPresentationTime: () => this.playhead_ ? this.playhead_.getTime() : 0,
  2864.       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
  2865.       mediaSourceEngine: this.mediaSourceEngine_,
  2866.       netEngine: this.networkingEngine_,
  2867.       onError: (error) => this.onError_(error),
  2868.       onEvent: (event) => this.dispatchEvent(event),
  2869.       onManifestUpdate: () => this.onManifestUpdate_(),
  2870.       onSegmentAppended: (start, end, contentType) => {
  2871.         this.onSegmentAppended_(start, end, contentType);
  2872.       },
  2873.       onInitSegmentAppended: (position, initSegment) => {
  2874.         const mediaQuality = initSegment.getMediaQuality();
  2875.         if (mediaQuality && this.qualityObserver_) {
  2876.           this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
  2877.         }
  2878.       },
  2879.       beforeAppendSegment: (contentType, segment) => {
  2880.         return this.drmEngine_.parseInbandPssh(contentType, segment);
  2881.       },
  2882.       onMetadata: (metadata, offset, endTime) => {
  2883.         this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
  2884.       },
  2885.       disableStream: (stream, time) => this.disableStream(stream, time),
  2886.     };
  2888.     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
  2889.   }
  2891.   /**
  2892.    * Changes configuration settings on the Player.  This checks the names of
  2893.    * keys and the types of values to avoid coding errors.  If there are errors,
  2894.    * this logs them to the console and returns false.  Correct fields are still
  2895.    * applied even if there are other errors.  You can pass an explicit
  2896.    * <code>undefined</code> value to restore the default value.  This has two
  2897.    * modes of operation:
  2898.    *
  2899.    * <p>
  2900.    * First, this can be passed a single "plain" object.  This object should
  2901.    * follow the {@link shaka.extern.PlayerConfiguration} object.  Not all fields
  2902.    * need to be set; unset fields retain their old values.
  2903.    *
  2904.    * <p>
  2905.    * Second, this can be passed two arguments.  The first is the name of the key
  2906.    * to set.  This should be a '.' separated path to the key.  For example,
  2907.    * <code>'streaming.alwaysStreamText'</code>.  The second argument is the
  2908.    * value to set.
  2909.    *
  2910.    * @param {string|!Object} config This should either be a field name or an
  2911.    *   object.
  2912.    * @param {*=} value In the second mode, this is the value to set.
  2913.    * @return {boolean} True if the passed config object was valid, false if
  2914.    *   there were invalid entries.
  2915.    * @export
  2916.    */
  2917.   configure(config, value) {
  2918.     goog.asserts.assert(this.config_, 'Config must not be null!');
  2919.     goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  2920.         'String configs should have values!');
  2922.     // ('fieldName', value) format
  2923.     if (arguments.length == 2 && typeof(config) == 'string') {
  2924.       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
  2925.     }
  2927.     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  2929.     // Deprecate 'streaming.forceTransmuxTS' configuration.
  2930.     if (config['streaming'] && 'forceTransmuxTS' in config['streaming']) {
  2931.       shaka.Deprecate.deprecateFeature(5,
  2932.           'streaming.forceTransmuxTS configuration',
  2933.           'Please Use mediaSource.forceTransmux instead.');
  2934.       config['mediaSource']['mediaSource'] =
  2935.           config['streaming']['forceTransmuxTS'];
  2936.       delete config['streaming']['forceTransmuxTS'];
  2937.     }
  2939.     // Deprecate 'streaming.forceTransmux' configuration.
  2940.     if (config['streaming'] && 'forceTransmux' in config['streaming']) {
  2941.       shaka.Deprecate.deprecateFeature(5,
  2942.           'streaming.forceTransmux configuration',
  2943.           'Please Use mediaSource.forceTransmux instead.');
  2944.       config['mediaSource']['mediaSource'] =
  2945.           config['streaming']['forceTransmux'];
  2946.       delete config['streaming']['forceTransmux'];
  2947.     }
  2949.     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
  2950.     // rebufferingGoal and segmentPrefetchLimit are not specified, set
  2951.     // inaccurateManifestTolerance to 0 and rebufferingGoal to 0.01 and
  2952.     // segmentPrefetchLimit to 2 by default for low latency streaming.
  2953.     if (config['streaming'] && config['streaming']['lowLatencyMode']) {
  2954.       if (config['streaming']['inaccurateManifestTolerance'] == undefined) {
  2955.         config['streaming']['inaccurateManifestTolerance'] = 0;
  2956.       }
  2957.       if (config['streaming']['rebufferingGoal'] == undefined) {
  2958.         config['streaming']['rebufferingGoal'] = 0.01;
  2959.       }
  2960.       if (config['streaming']['segmentPrefetchLimit'] == undefined) {
  2961.         config['streaming']['segmentPrefetchLimit'] = 2;
  2962.       }
  2963.     }
  2964.     const ret = shaka.util.PlayerConfiguration.mergeConfigObjects(
  2965.         this.config_, config, this.defaultConfig_());
  2967.     this.applyConfig_();
  2968.     return ret;
  2969.   }
  2971.   /**
  2972.    * Apply config changes.
  2973.    * @private
  2974.    */
  2975.   applyConfig_() {
  2976.     if (this.parser_) {
  2977.       const manifestConfig =
  2978.           shaka.util.ObjectUtils.cloneObject(this.config_.manifest);
  2979.       // Don't read video segments if the player is attached to an audio element
  2980.       if (this.video_ && this.video_.nodeName === 'AUDIO') {
  2981.         manifestConfig.disableVideo = true;
  2982.       }
  2983.       this.parser_.configure(manifestConfig);
  2984.     }
  2985.     if (this.drmEngine_) {
  2986.       this.drmEngine_.configure(this.config_.drm);
  2987.     }
  2988.     if (this.streamingEngine_) {
  2989.       this.streamingEngine_.configure(this.config_.streaming);
  2991.       // Need to apply the restrictions.
  2992.       try {
  2993.         // this.filterManifestWithRestrictions_() may throw.
  2994.         this.filterManifestWithRestrictions_(this.manifest_);
  2995.       } catch (error) {
  2996.         this.onError_(error);
  2997.       }
  2999.       if (this.abrManager_) {
  3000.         // Update AbrManager variants to match these new settings.
  3001.         this.updateAbrManagerVariants_();
  3002.       }
  3004.       // If the streams we are playing are restricted, we need to switch.
  3005.       const activeVariant = this.streamingEngine_.getCurrentVariant();
  3006.       if (activeVariant) {
  3007.         if (!activeVariant.allowedByApplication ||
  3008.             !activeVariant.allowedByKeySystem) {
  3009.           shaka.log.debug('Choosing new variant after changing configuration');
  3010.           this.chooseVariantAndSwitch_();
  3011.         }
  3012.       }
  3013.     }
  3014.     if (this.networkingEngine_) {
  3015.       this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
  3016.     }
  3018.     if (this.mediaSourceEngine_) {
  3019.       this.mediaSourceEngine_.configure(this.config_.mediaSource);
  3020.       const {segmentRelativeVttTiming} = this.config_.manifest;
  3021.       this.mediaSourceEngine_.setSegmentRelativeVttTiming(
  3022.           segmentRelativeVttTiming);
  3024.       const textDisplayerFactory = this.config_.textDisplayFactory;
  3025.       if (this.lastTextFactory_ != textDisplayerFactory) {
  3026.         const displayer = textDisplayerFactory();
  3027.         this.mediaSourceEngine_.setTextDisplayer(displayer);
  3028.         this.lastTextFactory_ = textDisplayerFactory;
  3030.         if (this.streamingEngine_) {
  3031.           // Reload the text stream, so the cues will load again.
  3032.           this.streamingEngine_.reloadTextStream();
  3033.         }
  3034.       }
  3035.     }
  3036.     if (this.abrManager_) {
  3037.       this.abrManager_.configure(this.config_.abr);
  3038.       // Simply enable/disable ABR with each call, since multiple calls to these
  3039.       // methods have no effect.
  3040.       if (this.config_.abr.enabled) {
  3041.         this.abrManager_.enable();
  3042.       } else {
  3043.         this.abrManager_.disable();
  3044.       }
  3046.       this.onAbrStatusChanged_();
  3047.     }
  3048.     if (this.bufferObserver_) {
  3049.       let rebufferThreshold = this.config_.streaming.rebufferingGoal;
  3050.       if (this.manifest_) {
  3051.         rebufferThreshold =
  3052.             Math.max(rebufferThreshold, this.manifest_.minBufferTime);
  3053.       }
  3054.       this.updateBufferingSettings_(rebufferThreshold);
  3055.     }
  3057.     if (this.manifest_) {
  3058.       shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
  3059.           this.config_.playRangeStart,
  3060.           this.config_.playRangeEnd);
  3061.     }
  3062.     if (this.adManager_) {
  3063.       this.adManager_.configure(this.config_.ads);
  3064.     }
  3065.     if (this.cmcdManager_) {
  3066.       this.cmcdManager_.configure(this.config_.cmcd);
  3067.     }
  3068.   }
  3070.   /**
  3071.    * Return a copy of the current configuration.  Modifications of the returned
  3072.    * value will not affect the Player's active configuration.  You must call
  3073.    * <code>player.configure()</code> to make changes.
  3074.    *
  3075.    * @return {shaka.extern.PlayerConfiguration}
  3076.    * @export
  3077.    */
  3078.   getConfiguration() {
  3079.     goog.asserts.assert(this.config_, 'Config must not be null!');
  3081.     const ret = this.defaultConfig_();
  3082.     shaka.util.PlayerConfiguration.mergeConfigObjects(
  3083.         ret, this.config_, this.defaultConfig_());
  3084.     return ret;
  3085.   }
  3087.   /**
  3088.    * Return a reference to the current configuration. Modifications to the
  3089.    * returned value will affect the Player's active configuration. This method
  3090.    * is not exported as sharing configuration with external objects is not
  3091.    * supported.
  3092.    *
  3093.    * @return {shaka.extern.PlayerConfiguration}
  3094.    */
  3095.   getSharedConfiguration() {
  3096.     goog.asserts.assert(
  3097.         this.config_, 'Cannot call getSharedConfiguration after call destroy!');
  3098.     return this.config_;
  3099.   }
  3101.   /**
  3102.    * Returns the ratio of video length buffered compared to buffering Goal
  3103.    * @return {number}
  3104.    * @export
  3105.    */
  3106.   getBufferFullness() {
  3107.     if (this.video_) {
  3108.       const bufferedLength = this.video_.buffered.length;
  3109.       const bufferedEnd =
  3110.           bufferedLength ? this.video_.buffered.end(bufferedLength - 1) : 0;
  3111.       const bufferingGoal = this.getConfiguration().streaming.bufferingGoal;
  3112.       const lengthToBeBuffered = Math.min(this.video_.currentTime +
  3113.           bufferingGoal, this.seekRange().end);
  3115.       if (bufferedEnd >= lengthToBeBuffered) {
  3116.         return 1;
  3117.       } else if (bufferedEnd <= this.video_.currentTime) {
  3118.         return 0;
  3119.       } else if (bufferedEnd < lengthToBeBuffered) {
  3120.         return ((bufferedEnd - this.video_.currentTime) /
  3121.             (lengthToBeBuffered - this.video_.currentTime));
  3122.       }
  3123.     }
  3124.     return 0;
  3125.   }
  3127.   /**
  3128.    * Reset configuration to default.
  3129.    * @export
  3130.    */
  3131.   resetConfiguration() {
  3132.     goog.asserts.assert(this.config_, 'Cannot be destroyed');
  3133.     // Remove the old keys so we remove open-ended dictionaries like drm.servers
  3134.     // but keeps the same object reference.
  3135.     for (const key in this.config_) {
  3136.       delete this.config_[key];
  3137.     }
  3139.     shaka.util.PlayerConfiguration.mergeConfigObjects(
  3140.         this.config_, this.defaultConfig_(), this.defaultConfig_());
  3141.     this.applyConfig_();
  3142.   }
  3144.   /**
  3145.    * Get the current load mode.
  3146.    *
  3147.    * @return {shaka.Player.LoadMode}
  3148.    * @export
  3149.    */
  3150.   getLoadMode() {
  3151.     return this.loadMode_;
  3152.   }
  3154.   /**
  3155.    * Get the current manifest type.
  3156.    *
  3157.    * @return {?string}
  3158.    * @export
  3159.    */
  3160.   getManifestType() {
  3161.     if (!this.manifest_) {
  3162.       return null;
  3163.     }
  3164.     return this.manifest_.type;
  3165.   }
  3167.   /**
  3168.    * Get the media element that the player is currently using to play loaded
  3169.    * content. If the player has not loaded content, this will return
  3170.    * <code>null</code>.
  3171.    *
  3172.    * @return {HTMLMediaElement}
  3173.    * @export
  3174.    */
  3175.   getMediaElement() {
  3176.     return this.video_;
  3177.   }
  3179.   /**
  3180.    * @return {shaka.net.NetworkingEngine} A reference to the Player's networking
  3181.    *     engine.  Applications may use this to make requests through Shaka's
  3182.    *     networking plugins.
  3183.    * @export
  3184.    */
  3185.   getNetworkingEngine() {
  3186.     return this.networkingEngine_;
  3187.   }
  3189.   /**
  3190.    * Get the uri to the asset that the player has loaded. If the player has not
  3191.    * loaded content, this will return <code>null</code>.
  3192.    *
  3193.    * @return {?string}
  3194.    * @export
  3195.    */
  3196.   getAssetUri() {
  3197.     return this.assetUri_;
  3198.   }
  3200.   /**
  3201.    * Returns a shaka.ads.AdManager instance, responsible for Dynamic
  3202.    * Ad Insertion functionality.
  3203.    *
  3204.    * @return {shaka.extern.IAdManager}
  3205.    * @export
  3206.    */
  3207.   getAdManager() {
  3208.     // NOTE: this clause is redundant, but it keeps the compiler from
  3209.     // inlining this function. Inlining leads to setting the adManager
  3210.     // not taking effect in the compiled build.
  3211.     // Closure has a @noinline flag, but apparently not all cases are
  3212.     // supported by it, and ours isn't.
  3213.     // If they expand support, we might be able to get rid of this
  3214.     // clause.
  3215.     if (!this.adManager_) {
  3216.       return null;
  3217.     }
  3219.     return this.adManager_;
  3220.   }
  3222.   /**
  3223.    * Get if the player is playing live content. If the player has not loaded
  3224.    * content, this will return <code>false</code>.
  3225.    *
  3226.    * @return {boolean}
  3227.    * @export
  3228.    */
  3229.   isLive() {
  3230.     if (this.manifest_) {
  3231.       return this.manifest_.presentationTimeline.isLive();
  3232.     }
  3234.     // For native HLS, the duration for live streams seems to be Infinity.
  3235.     if (this.video_ && this.video_.src) {
  3236.       return this.video_.duration == Infinity;
  3237.     }
  3239.     return false;
  3240.   }
  3242.   /**
  3243.    * Get if the player is playing in-progress content. If the player has not
  3244.    * loaded content, this will return <code>false</code>.
  3245.    *
  3246.    * @return {boolean}
  3247.    * @export
  3248.    */
  3249.   isInProgress() {
  3250.     return this.manifest_ ?
  3251.            this.manifest_.presentationTimeline.isInProgress() :
  3252.            false;
  3253.   }
  3255.   /**
  3256.    * Check if the manifest contains only audio-only content. If the player has
  3257.    * not loaded content, this will return <code>false</code>.
  3258.    *
  3259.    * <p>
  3260.    * The player does not support content that contain more than one type of
  3261.    * variants (i.e. mixing audio-only, video-only, audio-video). Content will be
  3262.    * filtered to only contain one type of variant.
  3263.    *
  3264.    * @return {boolean}
  3265.    * @export
  3266.    */
  3267.   isAudioOnly() {
  3268.     if (this.manifest_) {
  3269.       const variants = this.manifest_.variants;
  3270.       if (!variants.length) {
  3271.         return false;
  3272.       }
  3274.       // Note that if there are some audio-only variants and some audio-video
  3275.       // variants, the audio-only variants are removed during filtering.
  3276.       // Therefore if the first variant has no video, that's sufficient to say
  3277.       // it is audio-only content.
  3278.       return !variants[0].video;
  3279.     } else if (this.video_ && this.video_.src) {
  3280.       // If we have video track info, use that.  It will be the least
  3281.       // error-prone way with native HLS.  In contrast, videoHeight might be
  3282.       // unset until the first frame is loaded.  Since isAudioOnly is queried
  3283.       // by the UI on the 'trackschanged' event, the videoTracks info should be
  3284.       // up-to-date.
  3285.       if (this.video_.videoTracks) {
  3286.         return this.video_.videoTracks.length == 0;
  3287.       }
  3289.       // We cast to the more specific HTMLVideoElement to access videoHeight.
  3290.       // This might be an audio element, though, in which case videoHeight will
  3291.       // be undefined at runtime.  For audio elements, this will always return
  3292.       // true.
  3293.       const video = /** @type {HTMLVideoElement} */(this.video_);
  3294.       return video.videoHeight == 0;
  3295.     } else {
  3296.       return false;
  3297.     }
  3298.   }
  3300.   /**
  3301.    * Return the value of lowLatencyMode configuration.
  3302.    * @return {boolean}
  3303.    * @private
  3304.    */
  3305.   isLowLatencyMode_() {
  3306.     return this.config_.streaming.lowLatencyMode;
  3307.   }
  3309.   /**
  3310.    * Return the value of autoLowLatencyMode configuration.
  3311.    * @return {boolean}
  3312.    * @private
  3313.    */
  3314.   isAutoLowLatencyMode_() {
  3315.     return this.config_.streaming.autoLowLatencyMode;
  3316.   }
  3318.   /**
  3319.    * Get the range of time (in seconds) that seeking is allowed. If the player
  3320.    * has not loaded content and the manifest is HLS, this will return a range
  3321.    * from 0 to 0.
  3322.    *
  3323.    * @return {{start: number, end: number}}
  3324.    * @export
  3325.    */
  3326.   seekRange() {
  3327.     if (this.manifest_) {
  3328.       // With HLS lazy-loading, there were some situations where the manifest
  3329.       // had partially loaded, enough to move onto further load stages, but no
  3330.       // segments had been loaded, so the timeline is still unknown.
  3331.       // See: https://github.com/shaka-project/shaka-player/pull/4590
  3332.       if (!this.fullyLoaded_ &&
  3333.           this.manifest_.type == shaka.media.ManifestParser.HLS) {
  3334.         return {'start': 0, 'end': 0};
  3335.       }
  3336.       const timeline = this.manifest_.presentationTimeline;
  3338.       return {
  3339.         'start': timeline.getSeekRangeStart(),
  3340.         'end': timeline.getSeekRangeEnd(),
  3341.       };
  3342.     }
  3344.     // If we have loaded content with src=, we ask the video element for its
  3345.     // seekable range.  This covers both plain mp4s and native HLS playbacks.
  3346.     if (this.video_ && this.video_.src) {
  3347.       const seekable = this.video_.seekable;
  3348.       if (seekable.length) {
  3349.         return {
  3350.           'start': seekable.start(0),
  3351.           'end': seekable.end(seekable.length - 1),
  3352.         };
  3353.       }
  3354.     }
  3356.     return {'start': 0, 'end': 0};
  3357.   }
  3359.   /**
  3360.    * Go to live in a live stream.
  3361.    *
  3362.    * @export
  3363.    */
  3364.   goToLive() {
  3365.     if (this.isLive()) {
  3366.       this.video_.currentTime = this.seekRange().end;
  3367.     } else {
  3368.       shaka.log.warning('goToLive is for live streams!');
  3369.     }
  3370.   }
  3372.   /**
  3373.    * Get the key system currently used by EME. If EME is not being used, this
  3374.    * will return an empty string. If the player has not loaded content, this
  3375.    * will return an empty string.
  3376.    *
  3377.    * @return {string}
  3378.    * @export
  3379.    */
  3380.   keySystem() {
  3381.     return shaka.media.DrmEngine.keySystem(this.drmInfo());
  3382.   }
  3384.   /**
  3385.    * Get the drm info used to initialize EME. If EME is not being used, this
  3386.    * will return <code>null</code>. If the player is idle or has not initialized
  3387.    * EME yet, this will return <code>null</code>.
  3388.    *
  3389.    * @return {?shaka.extern.DrmInfo}
  3390.    * @export
  3391.    */
  3392.   drmInfo() {
  3393.     return this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  3394.   }
  3397.   /**
  3398.    * Get the drm engine.
  3399.    * This method should only be used for testing. Applications SHOULD NOT
  3400.    * use this in production.
  3401.    *
  3402.    * @return {?shaka.media.DrmEngine}
  3403.    */
  3404.   getDrmEngine() {
  3405.     return this.drmEngine_;
  3406.   }
  3409.   /**
  3410.    * Get the next known expiration time for any EME session. If the session
  3411.    * never expires, this will return <code>Infinity</code>. If there are no EME
  3412.    * sessions, this will return <code>Infinity</code>. If the player has not
  3413.    * loaded content, this will return <code>Infinity</code>.
  3414.    *
  3415.    * @return {number}
  3416.    * @export
  3417.    */
  3418.   getExpiration() {
  3419.     return this.drmEngine_ ? this.drmEngine_.getExpiration() : Infinity;
  3420.   }
  3422.   /**
  3423.    * Returns the active sessions metadata
  3424.    *
  3425.    * @return {!Array.<shaka.extern.DrmSessionMetadata>}
  3426.    * @export
  3427.    */
  3428.   getActiveSessionsMetadata() {
  3429.     return this.drmEngine_ ? this.drmEngine_.getActiveSessionsMetadata() : [];
  3430.   }
  3432.   /**
  3433.    * Gets a map of EME key ID to the current key status.
  3434.    *
  3435.    * @return {!Object<string, string>}
  3436.    * @export
  3437.    */
  3438.   getKeyStatuses() {
  3439.     return this.drmEngine_ ? this.drmEngine_.getKeyStatuses() : {};
  3440.   }
  3442.   /**
  3443.    * Check if the player is currently in a buffering state (has too little
  3444.    * content to play smoothly). If the player has not loaded content, this will
  3445.    * return <code>false</code>.
  3446.    *
  3447.    * @return {boolean}
  3448.    * @export
  3449.    */
  3450.   isBuffering() {
  3451.     const State = shaka.media.BufferingObserver.State;
  3452.     return this.bufferObserver_ ?
  3453.            this.bufferObserver_.getState() == State.STARVING :
  3454.            false;
  3455.   }
  3457.   /**
  3458.    * Get the playback rate of what is playing right now. If we are using trick
  3459.    * play, this will return the trick play rate.
  3460.    * If no content is playing, this will return 0.
  3461.    * If content is buffering, this will return the expected playback rate once
  3462.    * the video starts playing.
  3463.    *
  3464.    * <p>
  3465.    * If the player has not loaded content, this will return a playback rate of
  3466.    * 0.
  3467.    *
  3468.    * @return {number}
  3469.    * @export
  3470.    */
  3471.   getPlaybackRate() {
  3472.     if (!this.video_) {
  3473.       return 0;
  3474.     }
  3475.     return this.playRateController_ ?
  3476.            this.playRateController_.getRealRate() :
  3477.            1;
  3478.   }
  3480.   /**
  3481.    * Enable trick play to skip through content without playing by repeatedly
  3482.    * seeking. For example, a rate of 2.5 would result in 2.5 seconds of content
  3483.    * being skipped every second. A negative rate will result in moving
  3484.    * backwards.
  3485.    *
  3486.    * <p>
  3487.    * If the player has not loaded content or is still loading content this will
  3488.    * be a no-op. Wait until <code>load</code> has completed before calling.
  3489.    *
  3490.    * <p>
  3491.    * Trick play will be canceled automatically if the playhead hits the
  3492.    * beginning or end of the seekable range for the content.
  3493.    *
  3494.    * @param {number} rate
  3495.    * @export
  3496.    */
  3497.   trickPlay(rate) {
  3498.     // A playbackRate of 0 is used internally when we are in a buffering state,
  3499.     // and doesn't make sense for trick play.  If you set a rate of 0 for trick
  3500.     // play, we will reject it and issue a warning.  If it happens during a
  3501.     // test, we will fail the test through this assertion.
  3502.     goog.asserts.assert(rate != 0, 'Should never set a trick play rate of 0!');
  3503.     if (rate == 0) {
  3504.       shaka.log.alwaysWarn('A trick play rate of 0 is unsupported!');
  3505.       return;
  3506.     }
  3508.     if (this.video_.paused) {
  3509.       // Our fast forward is implemented with playbackRate and needs the video
  3510.       // to be playing (to not be paused) to take immediate effect.
  3511.       // If the video is paused, "unpause" it.
  3512.       this.video_.play();
  3513.     }
  3514.     this.playRateController_.set(rate);
  3516.     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  3517.       this.abrManager_.playbackRateChanged(rate);
  3518.       this.streamingEngine_.setTrickPlay(Math.abs(rate) > 1);
  3519.     }
  3520.   }
  3522.   /**
  3523.    * Cancel trick-play. If the player has not loaded content or is still loading
  3524.    * content this will be a no-op.
  3525.    *
  3526.    * @export
  3527.    */
  3528.   cancelTrickPlay() {
  3529.     const defaultPlaybackRate = this.playRateController_.getDefaultRate();
  3530.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  3531.       this.playRateController_.set(defaultPlaybackRate);
  3532.     }
  3534.     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  3535.       this.playRateController_.set(defaultPlaybackRate);
  3536.       this.abrManager_.playbackRateChanged(defaultPlaybackRate);
  3537.       this.streamingEngine_.setTrickPlay(false);
  3538.     }
  3539.   }
  3541.   /**
  3542.    * Return a list of variant tracks that can be switched to.
  3543.    *
  3544.    * <p>
  3545.    * If the player has not loaded content, this will return an empty list.
  3546.    *
  3547.    * @return {!Array.<shaka.extern.Track>}
  3548.    * @export
  3549.    */
  3550.   getVariantTracks() {
  3551.     if (this.manifest_) {
  3552.       const currentVariant = this.streamingEngine_ ?
  3553.           this.streamingEngine_.getCurrentVariant() : null;
  3555.       const tracks = [];
  3557.       let activeTracks = 0;
  3559.       // Convert each variant to a track.
  3560.       for (const variant of this.manifest_.variants) {
  3561.         if (!shaka.util.StreamUtils.isPlayable(variant)) {
  3562.           continue;
  3563.         }
  3565.         const track = shaka.util.StreamUtils.variantToTrack(variant);
  3566.         track.active = variant == currentVariant;
  3567.         if (!track.active && activeTracks != 1 && currentVariant != null &&
  3568.           variant.video == currentVariant.video &&
  3569.           variant.audio == currentVariant.audio) {
  3570.           track.active = true;
  3571.         }
  3573.         if (track.active) {
  3574.           activeTracks++;
  3575.         }
  3577.         tracks.push(track);
  3578.       }
  3580.       goog.asserts.assert(activeTracks <= 1,
  3581.           'It should only have one active track');
  3583.       return tracks;
  3584.     } else if (this.video_ && this.video_.audioTracks) {
  3585.       // Safari's native HLS always shows a single element in videoTracks.
  3586.       // You can't use that API to change resolutions.  But we can use
  3587.       // audioTracks to generate a variant list that is usable for changing
  3588.       // languages.
  3589.       const audioTracks = Array.from(this.video_.audioTracks);
  3590.       return audioTracks.map((audio) =>
  3591.         shaka.util.StreamUtils.html5AudioTrackToTrack(audio));
  3592.     } else {
  3593.       return [];
  3594.     }
  3595.   }
  3597.   /**
  3598.    * Return a list of text tracks that can be switched to.
  3599.    *
  3600.    * <p>
  3601.    * If the player has not loaded content, this will return an empty list.
  3602.    *
  3603.    * @return {!Array.<shaka.extern.Track>}
  3604.    * @export
  3605.    */
  3606.   getTextTracks() {
  3607.     if (this.manifest_) {
  3608.       const currentTextStream = this.streamingEngine_ ?
  3609.           this.streamingEngine_.getCurrentTextStream() : null;
  3610.       const tracks = [];
  3612.       // Convert all selectable text streams to tracks.
  3613.       for (const text of this.manifest_.textStreams) {
  3614.         const track = shaka.util.StreamUtils.textStreamToTrack(text);
  3615.         track.active = text == currentTextStream;
  3617.         tracks.push(track);
  3618.       }
  3620.       return tracks;
  3621.     } else if (this.video_ && this.video_.src && this.video_.textTracks) {
  3622.       const textTracks = this.getFilteredTextTracks_();
  3623.       const StreamUtils = shaka.util.StreamUtils;
  3624.       return textTracks.map((text) => StreamUtils.html5TextTrackToTrack(text));
  3625.     } else {
  3626.       return [];
  3627.     }
  3628.   }
  3630.   /**
  3631.    * Return a list of image tracks that can be switched to.
  3632.    *
  3633.    * If the player has not loaded content, this will return an empty list.
  3634.    *
  3635.    * @return {!Array.<shaka.extern.Track>}
  3636.    * @export
  3637.    */
  3638.   getImageTracks() {
  3639.     const StreamUtils = shaka.util.StreamUtils;
  3640.     let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
  3641.     if (this.manifest_) {
  3642.       imageStreams = this.manifest_.imageStreams;
  3643.     }
  3644.     return imageStreams.map((image) => StreamUtils.imageStreamToTrack(image));
  3645.   }
  3647.   /**
  3648.    * Returns Thumbnail objects for each thumbnail for a given image track ID.
  3649.    *
  3650.    * If the player has not loaded content, this will return a null.
  3651.    *
  3652.    * @param {number} trackId
  3653.    * @return {!Promise.<?Array<!shaka.extern.Thumbnail>>}
  3654.    * @export
  3655.    */
  3656.   async getAllThumbnails(trackId) {
  3657.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
  3658.         this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
  3659.       return null;
  3660.     }
  3661.     let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
  3662.     if (this.manifest_) {
  3663.       imageStreams = this.manifest_.imageStreams;
  3664.     }
  3665.     const imageStream = imageStreams.find(
  3666.         (stream) => stream.id == trackId);
  3667.     if (!imageStream) {
  3668.       return null;
  3669.     }
  3670.     if (!imageStream.segmentIndex) {
  3671.       await imageStream.createSegmentIndex();
  3672.     }
  3673.     const promises = [];
  3674.     imageStream.segmentIndex.forEachTopLevelReference((reference) => {
  3675.       const dimensions = this.parseTilesLayout_(
  3676.           reference.getTilesLayout() || imageStream.tilesLayout);
  3677.       if (dimensions) {
  3678.         const numThumbnails = dimensions.rows * dimensions.columns;
  3679.         const duration = reference.trueEndTime - reference.startTime;
  3680.         for (let i = 0; i < numThumbnails; i++) {
  3681.           const sampleTime = reference.startTime + duration * i / numThumbnails;
  3682.           promises.push(this.getThumbnails(trackId, sampleTime));
  3683.         }
  3684.       }
  3685.     });
  3686.     const thumbnails = await Promise.all(promises);
  3687.     return thumbnails.filter((t) => t);
  3688.   }
  3690.   /**
  3691.    * Parses a tiles layout.
  3692.    *
  3693.    * @param {string|undefined} tilesLayout
  3694.    * @return {?{
  3695.    *   columns: number,
  3696.    *   rows: number
  3697.    * }}
  3698.    * @private
  3699.    */
  3700.   parseTilesLayout_(tilesLayout) {
  3701.     if (!tilesLayout) {
  3702.       return null;
  3703.     }
  3704.     // This expression is used to detect one or more numbers (0-9) followed
  3705.     // by an x and after one or more numbers (0-9)
  3706.     const match = /(\d+)x(\d+)/.exec(tilesLayout);
  3707.     if (!match) {
  3708.       shaka.log.warning('Tiles layout does not contain a valid format ' +
  3709.           ' (columns x rows)');
  3710.       return null;
  3711.     }
  3712.     const columns = parseInt(match[1], 10);
  3713.     const rows = parseInt(match[2], 10);
  3714.     return {columns, rows};
  3715.   }
  3717.   /**
  3718.    * Return a Thumbnail object from a image track Id and time.
  3719.    *
  3720.    * If the player has not loaded content, this will return a null.
  3721.    *
  3722.    * @param {number} trackId
  3723.    * @param {number} time
  3724.    * @return {!Promise.<?shaka.extern.Thumbnail>}
  3725.    * @export
  3726.    */
  3727.   async getThumbnails(trackId, time) {
  3728.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
  3729.         this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
  3730.       return null;
  3731.     }
  3732.     let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
  3733.     if (this.manifest_) {
  3734.       imageStreams = this.manifest_.imageStreams;
  3735.     }
  3736.     const imageStream = imageStreams.find(
  3737.         (stream) => stream.id == trackId);
  3738.     if (!imageStream) {
  3739.       return null;
  3740.     }
  3741.     if (!imageStream.segmentIndex) {
  3742.       await imageStream.createSegmentIndex();
  3743.     }
  3744.     const referencePosition = imageStream.segmentIndex.find(time);
  3745.     if (referencePosition == null) {
  3746.       return null;
  3747.     }
  3748.     const reference = imageStream.segmentIndex.get(referencePosition);
  3749.     const dimensions = this.parseTilesLayout_(
  3750.         reference.getTilesLayout() || imageStream.tilesLayout);
  3751.     if (!dimensions) {
  3752.       return null;
  3753.     }
  3754.     const fullImageWidth = imageStream.width || 0;
  3755.     const fullImageHeight = imageStream.height || 0;
  3756.     let width = fullImageWidth / dimensions.columns;
  3757.     let height = fullImageHeight / dimensions.rows;
  3758.     const totalImages = dimensions.columns * dimensions.rows;
  3759.     const segmentDuration = reference.trueEndTime - reference.startTime;
  3760.     const thumbnailDuration =
  3761.         reference.getTileDuration() || (segmentDuration / totalImages);
  3762.     let thumbnailTime = reference.startTime;
  3763.     let positionX = 0;
  3764.     let positionY = 0;
  3765.     // If the number of images in the segment is greater than 1, we have to
  3766.     // find the correct image. For that we will return to the app the
  3767.     // coordinates of the position of the correct image.
  3768.     // Image search is always from left to right and top to bottom.
  3769.     // Note: The time between images within the segment is always
  3770.     // equidistant.
  3771.     //
  3772.     // Eg: Total images 5, tileLayout 5x1, segmentDuration 5, thumbnailTime 2
  3773.     // positionX = 0.4 * fullImageWidth
  3774.     // positionY = 0
  3775.     if (totalImages > 1) {
  3776.       const thumbnailPosition =
  3777.           Math.floor((time - reference.startTime) / thumbnailDuration);
  3778.       thumbnailTime = reference.startTime +
  3779.           (thumbnailPosition * thumbnailDuration);
  3780.       positionX = (thumbnailPosition % dimensions.columns) * width;
  3781.       positionY = Math.floor(thumbnailPosition / dimensions.columns) * height;
  3782.     }
  3783.     let sprite = false;
  3784.     const thumbnailSprite = reference.getThumbnailSprite();
  3785.     if (thumbnailSprite) {
  3786.       sprite = true;
  3787.       height = thumbnailSprite.height;
  3788.       positionX = thumbnailSprite.positionX;
  3789.       positionY = thumbnailSprite.positionY;
  3790.       width = thumbnailSprite.width;
  3791.     }
  3792.     return {
  3793.       segment: reference,
  3794.       imageHeight: fullImageHeight,
  3795.       imageWidth: fullImageWidth,
  3796.       height: height,
  3797.       positionX: positionX,
  3798.       positionY: positionY,
  3799.       startTime: thumbnailTime,
  3800.       duration: thumbnailDuration,
  3801.       uris: reference.getUris(),
  3802.       width: width,
  3803.       sprite: sprite,
  3804.     };
  3805.   }
  3807.   /**
  3808.    * Select a specific text track. <code>track</code> should come from a call to
  3809.    * <code>getTextTracks</code>. If the track is not found, this will be a
  3810.    * no-op. If the player has not loaded content, this will be a no-op.
  3811.    *
  3812.    * <p>
  3813.    * Note that <code>AdaptationEvents</code> are not fired for manual track
  3814.    * selections.
  3815.    *
  3816.    * @param {shaka.extern.Track} track
  3817.    * @export
  3818.    */
  3819.   selectTextTrack(track) {
  3820.     if (this.manifest_ && this.streamingEngine_) {
  3821.       const stream = this.manifest_.textStreams.find(
  3822.           (stream) => stream.id == track.id);
  3824.       if (!stream) {
  3825.         shaka.log.error('No stream with id', track.id);
  3826.         return;
  3827.       }
  3829.       if (stream == this.streamingEngine_.getCurrentTextStream()) {
  3830.         shaka.log.debug('Text track already selected.');
  3831.         return;
  3832.       }
  3834.       // Add entries to the history.
  3835.       this.addTextStreamToSwitchHistory_(stream, /* fromAdaptation= */ false);
  3836.       this.streamingEngine_.switchTextStream(stream);
  3837.       this.onTextChanged_();
  3839.       // Workaround for
  3840.       // https://github.com/shaka-project/shaka-player/issues/1299
  3841.       // When track is selected, back-propagate the language to
  3842.       // currentTextLanguage_.
  3843.       this.currentTextLanguage_ = stream.language;
  3844.     } else if (this.video_ && this.video_.src && this.video_.textTracks) {
  3845.       const textTracks = this.getFilteredTextTracks_();
  3846.       for (const textTrack of textTracks) {
  3847.         if (shaka.util.StreamUtils.html5TrackId(textTrack) == track.id) {
  3848.           // Leave the track in 'hidden' if it's selected but not showing.
  3849.           textTrack.mode = this.isTextVisible_ ? 'showing' : 'hidden';
  3850.         } else {
  3851.           // Safari allows multiple text tracks to have mode == 'showing', so be
  3852.           // explicit in resetting the others.
  3853.           textTrack.mode = 'disabled';
  3854.         }
  3855.       }
  3856.       this.onTextChanged_();
  3857.     }
  3858.   }
  3860.   /**
  3861.    * Select a specific variant track to play.  <code>track</code> should come
  3862.    * from a call to <code>getVariantTracks</code>. If <code>track</code> cannot
  3863.    * be found, this will be a no-op. If the player has not loaded content, this
  3864.    * will be a no-op.
  3865.    *
  3866.    * <p>
  3867.    * Changing variants will take effect once the currently buffered content has
  3868.    * been played. To force the change to happen sooner, use
  3869.    * <code>clearBuffer</code> with <code>safeMargin</code>. Setting
  3870.    * <code>clearBuffer</code> to <code>true</code> will clear all buffered
  3871.    * content after <code>safeMargin</code>, allowing the new variant to start
  3872.    * playing sooner.
  3873.    *
  3874.    * <p>
  3875.    * Note that <code>AdaptationEvents</code> are not fired for manual track
  3876.    * selections.
  3877.    *
  3878.    * @param {shaka.extern.Track} track
  3879.    * @param {boolean=} clearBuffer
  3880.    * @param {number=} safeMargin Optional amount of buffer (in seconds) to
  3881.    *   retain when clearing the buffer. Useful for switching variant quickly
  3882.    *   without causing a buffering event. Defaults to 0 if not provided. Ignored
  3883.    *   if clearBuffer is false. Can cause hiccups on some browsers if chosen too
  3884.    *   small, e.g. The amount of two segments is a fair minimum to consider as
  3885.    *   safeMargin value.
  3886.    * @export
  3887.    */
  3888.   selectVariantTrack(track, clearBuffer = false, safeMargin = 0) {
  3889.     if (this.manifest_ && this.streamingEngine_) {
  3890.       if (this.config_.abr.enabled) {
  3891.         shaka.log.alwaysWarn('Changing tracks while abr manager is enabled ' +
  3892.                              'will likely result in the selected track ' +
  3893.                              'being overriden. Consider disabling abr before ' +
  3894.                              'calling selectVariantTrack().');
  3895.       }
  3897.       const variant = this.manifest_.variants.find(
  3898.           (variant) => variant.id == track.id);
  3899.       if (!variant) {
  3900.         shaka.log.error('No variant with id', track.id);
  3901.         return;
  3902.       }
  3904.       // Double check that the track is allowed to be played. The track list
  3905.       // should only contain playable variants, but if restrictions change and
  3906.       // |selectVariantTrack| is called before the track list is updated, we
  3907.       // could get a now-restricted variant.
  3908.       if (!shaka.util.StreamUtils.isPlayable(variant)) {
  3909.         shaka.log.error('Unable to switch to restricted track', track.id);
  3910.         return;
  3911.       }
  3913.       this.switchVariant_(
  3914.           variant, /* fromAdaptation= */ false, clearBuffer, safeMargin);
  3916.       // Workaround for
  3917.       // https://github.com/shaka-project/shaka-player/issues/1299
  3918.       // When track is selected, back-propagate the language to
  3919.       // currentAudioLanguage_.
  3920.       this.currentAdaptationSetCriteria_ = new shaka.media.ExampleBasedCriteria(
  3921.           variant,
  3922.           this.config_.mediaSource.codecSwitchingStrategy,
  3923.           this.config_.manifest.dash.enableAudioGroups);
  3925.       // Update AbrManager variants to match these new settings.
  3926.       this.updateAbrManagerVariants_();
  3927.     } else if (this.video_ && this.video_.audioTracks) {
  3928.       // Safari's native HLS won't let you choose an explicit variant, though
  3929.       // you can choose audio languages this way.
  3930.       const audioTracks = Array.from(this.video_.audioTracks);
  3931.       for (const audioTrack of audioTracks) {
  3932.         if (shaka.util.StreamUtils.html5TrackId(audioTrack) == track.id) {
  3933.           // This will reset the "enabled" of other tracks to false.
  3934.           this.switchHtml5Track_(audioTrack);
  3935.           return;
  3936.         }
  3937.       }
  3938.     }
  3939.   }
  3941.   /**
  3942.    * Return a list of audio language-role combinations available.  If the
  3943.    * player has not loaded any content, this will return an empty list.
  3944.    *
  3945.    * @return {!Array.<shaka.extern.LanguageRole>}
  3946.    * @export
  3947.    */
  3948.   getAudioLanguagesAndRoles() {
  3949.     return shaka.Player.getLanguageAndRolesFrom_(this.getVariantTracks());
  3950.   }
  3952.   /**
  3953.    * Return a list of text language-role combinations available.  If the player
  3954.    * has not loaded any content, this will be return an empty list.
  3955.    *
  3956.    * @return {!Array.<shaka.extern.LanguageRole>}
  3957.    * @export
  3958.    */
  3959.   getTextLanguagesAndRoles() {
  3960.     return shaka.Player.getLanguageAndRolesFrom_(this.getTextTracks());
  3961.   }
  3963.   /**
  3964.    * Return a list of audio languages available. If the player has not loaded
  3965.    * any content, this will return an empty list.
  3966.    *
  3967.    * @return {!Array.<string>}
  3968.    * @export
  3969.    */
  3970.   getAudioLanguages() {
  3971.     return Array.from(shaka.Player.getLanguagesFrom_(this.getVariantTracks()));
  3972.   }
  3974.   /**
  3975.    * Return a list of text languages available. If the player has not loaded
  3976.    * any content, this will return an empty list.
  3977.    *
  3978.    * @return {!Array.<string>}
  3979.    * @export
  3980.    */
  3981.   getTextLanguages() {
  3982.     return Array.from(shaka.Player.getLanguagesFrom_(this.getTextTracks()));
  3983.   }
  3985.   /**
  3986.    * Sets the current audio language and current variant role to the selected
  3987.    * language, role and channel count, and chooses a new variant if need be.
  3988.    * If the player has not loaded any content, this will be a no-op.
  3989.    *
  3990.    * @param {string} language
  3991.    * @param {string=} role
  3992.    * @param {number=} channelsCount
  3993.    * @param {number=} safeMargin
  3994.    * @export
  3995.    */
  3996.   selectAudioLanguage(language, role, channelsCount = 0, safeMargin = 0) {
  3997.     if (this.manifest_ && this.playhead_) {
  3998.       this.currentAdaptationSetCriteria_ =
  3999.           new shaka.media.PreferenceBasedCriteria(
  4000.               language,
  4001.               role || '',
  4002.               channelsCount,
  4003.               /* hdrLevel= */ '',
  4004.               /* videoLayout= */ '',
  4005.               /* label= */ '',
  4006.               this.config_.mediaSource.codecSwitchingStrategy,
  4007.               this.config_.manifest.dash.enableAudioGroups);
  4009.       const diff = (a, b) => {
  4010.         if (!a.video && !b.video) {
  4011.           return 0;
  4012.         } else if (!a.video || !b.video) {
  4013.           return Infinity;
  4014.         } else {
  4015.           return Math.abs((a.video.height || 0) - (b.video.height || 0)) +
  4016.                 Math.abs((a.video.width || 0) - (b.video.width || 0));
  4017.         }
  4018.       };
  4019.         // Find the variant whose size is closest to the active variant.  This
  4020.         // ensures we stay at about the same resolution when just changing the
  4021.         // language/role.
  4022.       const active = this.streamingEngine_.getCurrentVariant();
  4023.       const set =
  4024.             this.currentAdaptationSetCriteria_.create(this.manifest_.variants);
  4025.       let bestVariant = null;
  4026.       for (const curVariant of set.values()) {
  4027.         if (!bestVariant ||
  4028.               diff(bestVariant, active) > diff(curVariant, active)) {
  4029.           bestVariant = curVariant;
  4030.         }
  4031.       }
  4032.       if (bestVariant) {
  4033.         const track = shaka.util.StreamUtils.variantToTrack(bestVariant);
  4034.         this.selectVariantTrack(track, /* clearBuffer= */ true, safeMargin);
  4035.         return;
  4036.       }
  4038.       // If we haven't switched yet, just use ABR to find a new track.
  4039.       this.chooseVariantAndSwitch_();
  4040.     } else if (this.video_ && this.video_.audioTracks) {
  4041.       const track = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  4042.           this.getVariantTracks(), language, role || '', false)[0];
  4043.       if (track) {
  4044.         this.selectVariantTrack(track);
  4045.       }
  4046.     }
  4047.   }
  4049.   /**
  4050.    * Sets the current text language and current text role to the selected
  4051.    * language and role, and chooses a new variant if need be. If the player has
  4052.    * not loaded any content, this will be a no-op.
  4053.    *
  4054.    * @param {string} language
  4055.    * @param {string=} role
  4056.    * @param {boolean=} forced
  4057.    * @export
  4058.    */
  4059.   selectTextLanguage(language, role, forced = false) {
  4060.     if (this.manifest_ && this.playhead_) {
  4061.       this.currentTextLanguage_ = language;
  4062.       this.currentTextRole_ = role || '';
  4063.       this.currentTextForced_ = forced;
  4065.       const chosenText = this.chooseTextStream_();
  4066.       if (chosenText) {
  4067.         if (chosenText == this.streamingEngine_.getCurrentTextStream()) {
  4068.           shaka.log.debug('Text track already selected.');
  4069.           return;
  4070.         }
  4072.         this.addTextStreamToSwitchHistory_(
  4073.             chosenText, /* fromAdaptation= */ false);
  4074.         if (this.shouldStreamText_()) {
  4075.           this.streamingEngine_.switchTextStream(chosenText);
  4076.           this.onTextChanged_();
  4077.         }
  4078.       }
  4079.     } else {
  4080.       const track = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  4081.           this.getTextTracks(), language, role || '', forced)[0];
  4082.       if (track) {
  4083.         this.selectTextTrack(track);
  4084.       }
  4085.     }
  4086.   }
  4088.   /**
  4089.    * Select variant tracks that have a given label. This assumes the
  4090.    * label uniquely identifies an audio stream, so all the variants
  4091.    * are expected to have the same variant.audio.
  4092.    *
  4093.    * @param {string} label
  4094.    * @param {boolean=} clearBuffer Optional clear buffer or not when
  4095.    *  switch to new variant
  4096.    *  Defaults to true if not provided
  4097.    * @param {number=} safeMargin Optional amount of buffer (in seconds) to
  4098.    *   retain when clearing the buffer.
  4099.    *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
  4100.    * @export
  4101.    */
  4102.   selectVariantsByLabel(label, clearBuffer = true, safeMargin = 0) {
  4103.     if (this.manifest_ && this.playhead_) {
  4104.       let firstVariantWithLabel = null;
  4105.       for (const variant of this.manifest_.variants) {
  4106.         if (variant.audio.label == label) {
  4107.           firstVariantWithLabel = variant;
  4108.           break;
  4109.         }
  4110.       }
  4112.       if (firstVariantWithLabel == null) {
  4113.         shaka.log.warning('No variants were found with label: ' +
  4114.             label + '. Ignoring the request to switch.');
  4116.         return;
  4117.       }
  4119.       // Label is a unique identifier of a variant's audio stream.
  4120.       // Because of that we assume that all the variants with the same
  4121.       // label have the same language.
  4122.       this.currentAdaptationSetCriteria_ =
  4123.           new shaka.media.PreferenceBasedCriteria(
  4124.               firstVariantWithLabel.language,
  4125.               /* role= */ '',
  4126.               /* channelCount= */ 0,
  4127.               /* hdrLevel= */ '',
  4128.               /* videoLayout= */ '',
  4129.               label,
  4130.               this.config_.mediaSource.codecSwitchingStrategy,
  4131.               this.config_.manifest.dash.enableAudioGroups);
  4133.       this.chooseVariantAndSwitch_(clearBuffer, safeMargin);
  4134.     } else if (this.video_ && this.video_.audioTracks) {
  4135.       const audioTracks = Array.from(this.video_.audioTracks);
  4137.       let trackMatch = null;
  4139.       for (const audioTrack of audioTracks) {
  4140.         if (audioTrack.label == label) {
  4141.           trackMatch = audioTrack;
  4142.         }
  4143.       }
  4144.       if (trackMatch) {
  4145.         this.switchHtml5Track_(trackMatch);
  4146.       }
  4147.     }
  4148.   }
  4150.   /**
  4151.    * Check if the text displayer is enabled.
  4152.    *
  4153.    * @return {boolean}
  4154.    * @export
  4155.    */
  4156.   isTextTrackVisible() {
  4157.     const expected = this.isTextVisible_;
  4159.     if (this.mediaSourceEngine_ &&
  4160.         this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  4161.       // Make sure our values are still in-sync.
  4162.       const actual = this.mediaSourceEngine_.getTextDisplayer().isTextVisible();
  4163.       goog.asserts.assert(
  4164.           actual == expected, 'text visibility has fallen out of sync');
  4166.       // Always return the actual value so that the app has the most accurate
  4167.       // information (in the case that the values come out of sync in prod).
  4168.       return actual;
  4169.     } else if (this.video_ && this.video_.src && this.video_.textTracks) {
  4170.       const textTracks = this.getFilteredTextTracks_();
  4171.       return textTracks.some((t) => t.mode == 'showing');
  4172.     }
  4174.     return expected;
  4175.   }
  4177.   /**
  4178.    * Return a list of chapters tracks.
  4179.    *
  4180.    * @return {!Array.<shaka.extern.Track>}
  4181.    * @export
  4182.    */
  4183.   getChaptersTracks() {
  4184.     if (this.video_ && this.video_.src && this.video_.textTracks) {
  4185.       const textTracks = this.getChaptersTracks_();
  4186.       const StreamUtils = shaka.util.StreamUtils;
  4187.       return textTracks.map((text) => StreamUtils.html5TextTrackToTrack(text));
  4188.     } else {
  4189.       return [];
  4190.     }
  4191.   }
  4193.   /**
  4194.    * This returns the list of chapters.
  4195.    *
  4196.    * @param {string} language
  4197.    * @return {!Array.<shaka.extern.Chapter>}
  4198.    * @export
  4199.    */
  4200.   getChapters(language) {
  4201.     if (!this.video_ || !this.video_.src || !this.video_.textTracks) {
  4202.       return [];
  4203.     }
  4204.     const LanguageUtils = shaka.util.LanguageUtils;
  4205.     const inputlanguage = LanguageUtils.normalize(language);
  4206.     const chaptersTracks = this.getChaptersTracks_();
  4207.     const chaptersTracksWithLanguage = chaptersTracks
  4208.         .filter((t) => LanguageUtils.normalize(t.language) == inputlanguage);
  4209.     if (!chaptersTracksWithLanguage || !chaptersTracksWithLanguage.length) {
  4210.       return [];
  4211.     }
  4212.     const chapters = [];
  4213.     const uniqueChapters = new Set();
  4214.     for (const chaptersTrack of chaptersTracksWithLanguage) {
  4215.       if (chaptersTrack && chaptersTrack.cues) {
  4216.         for (const cue of chaptersTrack.cues) {
  4217.           let id = cue.id;
  4218.           if (!id || id == '') {
  4219.             id = cue.startTime + '-' + cue.endTime + '-' + cue.text;
  4220.           }
  4221.           /** @type {shaka.extern.Chapter} */
  4222.           const chapter = {
  4223.             id: id,
  4224.             title: cue.text,
  4225.             startTime: cue.startTime,
  4226.             endTime: cue.endTime,
  4227.           };
  4228.           if (!uniqueChapters.has(id)) {
  4229.             chapters.push(chapter);
  4230.             uniqueChapters.add(id);
  4231.           }
  4232.         }
  4233.       }
  4234.     }
  4235.     return chapters;
  4236.   }
  4238.   /**
  4239.    * Ignore the TextTracks with the 'metadata' or 'chapters' kind, or the one
  4240.    * generated by the SimpleTextDisplayer.
  4241.    *
  4242.    * @return {!Array.<TextTrack>}
  4243.    * @private
  4244.    */
  4245.   getFilteredTextTracks_() {
  4246.     goog.asserts.assert(this.video_.textTracks,
  4247.         'TextTracks should be valid.');
  4248.     return Array.from(this.video_.textTracks)
  4249.         .filter((t) => t.kind != 'metadata' && t.kind != 'chapters' &&
  4250.                        t.label != shaka.Player.TextTrackLabel);
  4251.   }
  4253.   /**
  4254.    * Get the TextTracks with the 'metadata' kind.
  4255.    *
  4256.    * @return {!Array.<TextTrack>}
  4257.    * @private
  4258.    */
  4259.   getMetadataTracks_() {
  4260.     goog.asserts.assert(this.video_.textTracks,
  4261.         'TextTracks should be valid.');
  4262.     return Array.from(this.video_.textTracks)
  4263.         .filter((t) => t.kind == 'metadata');
  4264.   }
  4266.   /**
  4267.    * Get the TextTracks with the 'chapters' kind.
  4268.    *
  4269.    * @return {!Array.<TextTrack>}
  4270.    * @private
  4271.    */
  4272.   getChaptersTracks_() {
  4273.     goog.asserts.assert(this.video_.textTracks,
  4274.         'TextTracks should be valid.');
  4275.     return Array.from(this.video_.textTracks)
  4276.         .filter((t) => t.kind == 'chapters');
  4277.   }
  4279.   /**
  4280.    * Enable or disable the text displayer.  If the player is in an unloaded
  4281.    * state, the request will be applied next time content is loaded.
  4282.    *
  4283.    * @param {boolean} isVisible
  4284.    * @export
  4285.    */
  4286.   setTextTrackVisibility(isVisible) {
  4287.     const oldVisibilty = this.isTextVisible_;
  4288.     // Convert to boolean in case apps pass 0/1 instead false/true.
  4289.     const newVisibility = !!isVisible;
  4291.     if (oldVisibilty == newVisibility) {
  4292.       return;
  4293.     }
  4295.     this.isTextVisible_ = newVisibility;
  4297.     // Hold of on setting the text visibility until we have all the components
  4298.     // we need. This ensures that they stay in-sync.
  4299.     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  4300.       this.mediaSourceEngine_.getTextDisplayer()
  4301.           .setTextVisibility(newVisibility);
  4303.       // When the user wants to see captions, we stream captions. When the user
  4304.       // doesn't want to see captions, we don't stream captions. This is to
  4305.       // avoid bandwidth consumption by an unused resource. The app developer
  4306.       // can override this and configure us to always stream captions.
  4307.       if (!this.config_.streaming.alwaysStreamText) {
  4308.         if (newVisibility) {
  4309.           if (this.streamingEngine_.getCurrentTextStream()) {
  4310.             // We already have a selected text stream.
  4311.           } else {
  4312.             // Find the text stream that best matches the user's preferences.
  4313.             const streams =
  4314.                 shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  4315.                     this.manifest_.textStreams,
  4316.                     this.currentTextLanguage_,
  4317.                     this.currentTextRole_,
  4318.                     this.currentTextForced_);
  4320.             // It is possible that there are no streams to play.
  4321.             if (streams.length > 0) {
  4322.               this.streamingEngine_.switchTextStream(streams[0]);
  4323.               this.onTextChanged_();
  4324.             }
  4325.           }
  4326.         } else {
  4327.           this.streamingEngine_.unloadTextStream();
  4328.         }
  4329.       }
  4330.     } else if (this.video_ && this.video_.src && this.video_.textTracks) {
  4331.       const textTracks = this.getFilteredTextTracks_();
  4332.       // Find the active track by looking for one which is not disabled.  This
  4333.       // is the only way to identify the track which is currently displayed.
  4334.       // Set it to 'showing' or 'hidden' based on newVisibility.
  4335.       for (const textTrack of textTracks) {
  4336.         if (textTrack.mode != 'disabled') {
  4337.           textTrack.mode = newVisibility ? 'showing' : 'hidden';
  4338.         }
  4339.       }
  4340.     }
  4342.     // We need to fire the event after we have updated everything so that
  4343.     // everything will be in a stable state when the app responds to the
  4344.     // event.
  4345.     this.onTextTrackVisibility_();
  4346.   }
  4348.   /**
  4349.    * Get the current playhead position as a date. This should only be called
  4350.    * when the player has loaded a live stream. If the player has not loaded a
  4351.    * live stream, this will return <code>null</code>.
  4352.    *
  4353.    * @return {Date}
  4354.    * @export
  4355.    */
  4356.   getPlayheadTimeAsDate() {
  4357.     if (!this.isLive()) {
  4358.       shaka.log.warning('getPlayheadTimeAsDate is for live streams!');
  4359.       return null;
  4360.     }
  4362.     let presentationTime = 0;
  4363.     if (this.playhead_) {
  4364.       presentationTime = this.playhead_.getTime();
  4365.     } else if (this.startTime_ == null) {
  4366.       // A live stream with no requested start time and no playhead yet.  We
  4367.       // would start at the live edge, but we don't have that yet, so return
  4368.       // the current date & time.
  4369.       return new Date();
  4370.     } else {
  4371.       // A specific start time has been requested.  This is what Playhead will
  4372.       // use once it is created.
  4373.       presentationTime = this.startTime_;
  4374.     }
  4376.     if (this.manifest_) {
  4377.       const timeline = this.manifest_.presentationTimeline;
  4378.       const startTime = timeline.getPresentationStartTime();
  4379.       return new Date(/* ms= */ (startTime + presentationTime) * 1000);
  4380.     } else if (this.video_ && this.video_.getStartDate) {
  4381.       // Apple's native HLS gives us getStartDate(), which is only available if
  4382.       // EXT-X-PROGRAM-DATETIME is in the playlist.
  4383.       const startDate = this.video_.getStartDate();
  4384.       if (isNaN(startDate.getTime())) {
  4385.         shaka.log.warning(
  4386.             'EXT-X-PROGRAM-DATETIME required to get playhead time as Date!');
  4387.         return null;
  4388.       }
  4389.       return new Date(startDate.getTime() + (presentationTime * 1000));
  4390.     } else {
  4391.       shaka.log.warning('No way to get playhead time as Date!');
  4392.       return null;
  4393.     }
  4394.   }
  4396.   /**
  4397.    * Get the presentation start time as a date. This should only be called when
  4398.    * the player has loaded a live stream. If the player has not loaded a live
  4399.    * stream, this will return <code>null</code>.
  4400.    *
  4401.    * @return {Date}
  4402.    * @export
  4403.    */
  4404.   getPresentationStartTimeAsDate() {
  4405.     if (!this.isLive()) {
  4406.       shaka.log.warning('getPresentationStartTimeAsDate is for live streams!');
  4407.       return null;
  4408.     }
  4410.     if (this.manifest_) {
  4411.       const timeline = this.manifest_.presentationTimeline;
  4412.       const startTime = timeline.getPresentationStartTime();
  4413.       goog.asserts.assert(startTime != null,
  4414.           'Presentation start time should not be null!');
  4415.       return new Date(/* ms= */ startTime * 1000);
  4416.     } else if (this.video_ && this.video_.getStartDate) {
  4417.       // Apple's native HLS gives us getStartDate(), which is only available if
  4418.       // EXT-X-PROGRAM-DATETIME is in the playlist.
  4419.       const startDate = this.video_.getStartDate();
  4420.       if (isNaN(startDate.getTime())) {
  4421.         shaka.log.warning(
  4422.             'EXT-X-PROGRAM-DATETIME required to get presentation start time ' +
  4423.             'as Date!');
  4424.         return null;
  4425.       }
  4426.       return startDate;
  4427.     } else {
  4428.       shaka.log.warning('No way to get presentation start time as Date!');
  4429.       return null;
  4430.     }
  4431.   }
  4433.   /**
  4434.    * Get information about what the player has buffered. If the player has not
  4435.    * loaded content or is currently loading content, the buffered content will
  4436.    * be empty.
  4437.    *
  4438.    * @return {shaka.extern.BufferedInfo}
  4439.    * @export
  4440.    */
  4441.   getBufferedInfo() {
  4442.     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  4443.       return this.mediaSourceEngine_.getBufferedInfo();
  4444.     }
  4446.     const info = {
  4447.       total: [],
  4448.       audio: [],
  4449.       video: [],
  4450.       text: [],
  4451.     };
  4453.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  4454.       const TimeRangesUtils = shaka.media.TimeRangesUtils;
  4455.       info.total = TimeRangesUtils.getBufferedInfo(this.video_.buffered);
  4456.     }
  4458.     return info;
  4459.   }
  4461.   /**
  4462.    * Get statistics for the current playback session. If the player is not
  4463.    * playing content, this will return an empty stats object.
  4464.    *
  4465.    * @return {shaka.extern.Stats}
  4466.    * @export
  4467.    */
  4468.   getStats() {
  4469.     // If the Player is not in a fully-loaded state, then return an empty stats
  4470.     // blob so that this call will never fail.
  4471.     const loaded = this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE ||
  4472.                    this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS;
  4473.     if (!loaded) {
  4474.       return shaka.util.Stats.getEmptyBlob();
  4475.     }
  4477.     this.updateStateHistory_();
  4479.     goog.asserts.assert(this.video_, 'If we have stats, we should have video_');
  4480.     const element = /** @type {!HTMLVideoElement} */ (this.video_);
  4482.     const completionRatio = element.currentTime / element.duration;
  4483.     if (!isNaN(completionRatio)) {
  4484.       this.stats_.setCompletionPercent(Math.round(100 * completionRatio));
  4485.     }
  4487.     if (this.playhead_) {
  4488.       this.stats_.setGapsJumped(this.playhead_.getGapsJumped());
  4489.       this.stats_.setStallsDetected(this.playhead_.getStallsDetected());
  4490.     }
  4492.     if (element.getVideoPlaybackQuality) {
  4493.       const info = element.getVideoPlaybackQuality();
  4495.       this.stats_.setDroppedFrames(
  4496.           Number(info.droppedVideoFrames),
  4497.           Number(info.totalVideoFrames));
  4498.       this.stats_.setCorruptedFrames(Number(info.corruptedVideoFrames));
  4499.     }
  4501.     const licenseSeconds =
  4502.         this.drmEngine_ ? this.drmEngine_.getLicenseTime() : NaN;
  4503.     this.stats_.setLicenseTime(licenseSeconds);
  4505.     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
  4506.       // Event through we are loaded, it is still possible that we don't have a
  4507.       // variant yet because we set the load mode before we select the first
  4508.       // variant to stream.
  4509.       const variant = this.streamingEngine_.getCurrentVariant();
  4511.       if (variant) {
  4512.         const rate = this.playRateController_ ?
  4513.            this.playRateController_.getRealRate() : 1;
  4514.         const variantBandwidth = rate * variant.bandwidth;
  4515.         // TODO: Should include text bandwidth if it enabled.
  4516.         const currentStreamBandwidth = variantBandwidth;
  4517.         this.stats_.setCurrentStreamBandwidth(currentStreamBandwidth);
  4518.       }
  4520.       if (variant && variant.video) {
  4521.         this.stats_.setResolution(
  4522.             /* width= */ variant.video.width || NaN,
  4523.             /* height= */ variant.video.height || NaN);
  4524.       }
  4526.       if (this.isLive()) {
  4527.         const now = this.getPresentationStartTimeAsDate().valueOf() +
  4528.             this.seekRange().end * 1000;
  4529.         const latency = (Date.now() - now) / 1000;
  4530.         this.stats_.setLiveLatency(latency);
  4531.       }
  4533.       if (this.manifest_ && this.manifest_.presentationTimeline) {
  4534.         const maxSegmentDuration =
  4535.             this.manifest_.presentationTimeline.getMaxSegmentDuration();
  4536.         this.stats_.setMaxSegmentDuration(maxSegmentDuration);
  4537.       }
  4539.       const estimate = this.abrManager_.getBandwidthEstimate();
  4540.       this.stats_.setBandwidthEstimate(estimate);
  4541.     }
  4543.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  4544.       this.stats_.setResolution(
  4545.           /* width= */ element.videoWidth || NaN,
  4546.           /* height= */ element.videoHeight || NaN);
  4547.     }
  4549.     return this.stats_.getBlob();
  4550.   }
  4552.   /**
  4553.    * Adds the given text track to the loaded manifest.  <code>load()</code> must
  4554.    * resolve before calling.  The presentation must have a duration.
  4555.    *
  4556.    * This returns the created track, which can immediately be selected by the
  4557.    * application.  The track will not be automatically selected.
  4558.    *
  4559.    * @param {string} uri
  4560.    * @param {string} language
  4561.    * @param {string} kind
  4562.    * @param {string=} mimeType
  4563.    * @param {string=} codec
  4564.    * @param {string=} label
  4565.    * @param {boolean=} forced
  4566.    * @return {!Promise.<shaka.extern.Track>}
  4567.    * @export
  4568.    */
  4569.   async addTextTrackAsync(uri, language, kind, mimeType, codec, label,
  4570.       forced = false) {
  4571.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
  4572.         this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
  4573.       shaka.log.error(
  4574.           'Must call load() and wait for it to resolve before adding text ' +
  4575.           'tracks.');
  4576.       throw new shaka.util.Error(
  4577.           shaka.util.Error.Severity.RECOVERABLE,
  4578.           shaka.util.Error.Category.PLAYER,
  4579.           shaka.util.Error.Code.CONTENT_NOT_LOADED);
  4580.     }
  4582.     if (!mimeType) {
  4583.       mimeType = await this.getTextMimetype_(uri);
  4584.     }
  4586.     let adCuePoints = [];
  4587.     if (this.adManager_) {
  4588.       adCuePoints = this.adManager_.getCuePoints();
  4589.     }
  4591.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  4592.       if (forced) {
  4593.         // See: https://github.com/whatwg/html/issues/4472
  4594.         kind = 'forced';
  4595.       }
  4596.       await this.addSrcTrackElement_(uri, language, kind, mimeType, label || '',
  4597.           adCuePoints);
  4598.       const textTracks = this.getTextTracks();
  4599.       const srcTrack = textTracks.find((t) => {
  4600.         return t.language == language &&
  4601.             t.label == (label || '') &&
  4602.             t.kind == kind;
  4603.       });
  4604.       if (srcTrack) {
  4605.         this.onTracksChanged_();
  4606.         return srcTrack;
  4607.       }
  4608.       // This should not happen, but there are browser implementations that may
  4609.       // not support the Track element.
  4610.       shaka.log.error('Cannot add this text when loaded with src=');
  4611.       throw new shaka.util.Error(
  4612.           shaka.util.Error.Severity.RECOVERABLE,
  4613.           shaka.util.Error.Category.TEXT,
  4614.           shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_SRC_EQUALS);
  4615.     }
  4617.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  4619.     let duration = this.video_.duration;
  4620.     if (this.manifest_) {
  4621.       duration = this.manifest_.presentationTimeline.getDuration();
  4622.     }
  4623.     if (duration == Infinity) {
  4624.       throw new shaka.util.Error(
  4625.           shaka.util.Error.Severity.RECOVERABLE,
  4626.           shaka.util.Error.Category.MANIFEST,
  4627.           shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_LIVE_STREAM);
  4628.     }
  4630.     if (adCuePoints.length) {
  4631.       goog.asserts.assert(
  4632.           this.networkingEngine_, 'Need networking engine.');
  4633.       const data = await this.getTextData_(uri,
  4634.           this.networkingEngine_,
  4635.           this.config_.streaming.retryParameters);
  4636.       const vvtText = this.convertToWebVTT_(data, mimeType, adCuePoints);
  4637.       const blob = new Blob([vvtText], {type: 'text/vtt'});
  4638.       uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
  4639.       mimeType = 'text/vtt';
  4640.     }
  4642.     /** @type {shaka.extern.Stream} */
  4643.     const stream = {
  4644.       id: this.nextExternalStreamId_++,
  4645.       originalId: null,
  4646.       groupId: null,
  4647.       createSegmentIndex: () => Promise.resolve(),
  4648.       segmentIndex: shaka.media.SegmentIndex.forSingleSegment(
  4649.           /* startTime= */ 0,
  4650.           /* duration= */ duration,
  4651.           /* uris= */ [uri]),
  4652.       mimeType: mimeType || '',
  4653.       codecs: codec || '',
  4654.       kind: kind,
  4655.       encrypted: false,
  4656.       drmInfos: [],
  4657.       keyIds: new Set(),
  4658.       language: language,
  4659.       originalLanguage: language,
  4660.       label: label || null,
  4661.       type: ContentType.TEXT,
  4662.       primary: false,
  4663.       trickModeVideo: null,
  4664.       emsgSchemeIdUris: null,
  4665.       roles: [],
  4666.       forced: !!forced,
  4667.       channelsCount: null,
  4668.       audioSamplingRate: null,
  4669.       spatialAudio: false,
  4670.       closedCaptions: null,
  4671.       accessibilityPurpose: null,
  4672.       external: true,
  4673.       fastSwitching: false,
  4674.     };
  4676.     const fullMimeType = shaka.util.MimeUtils.getFullType(
  4677.         stream.mimeType, stream.codecs);
  4678.     const supported = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  4679.     if (!supported) {
  4680.       throw new shaka.util.Error(
  4681.           shaka.util.Error.Severity.CRITICAL,
  4682.           shaka.util.Error.Category.TEXT,
  4683.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  4684.           mimeType);
  4685.     }
  4687.     this.manifest_.textStreams.push(stream);
  4688.     this.onTracksChanged_();
  4689.     return shaka.util.StreamUtils.textStreamToTrack(stream);
  4690.   }
  4692.   /**
  4693.    * Adds the given thumbnails track to the loaded manifest.
  4694.    * <code>load()</code> must resolve before calling.  The presentation must
  4695.    * have a duration.
  4696.    *
  4697.    * This returns the created track, which can immediately be used by the
  4698.    * application.
  4699.    *
  4700.    * @param {string} uri
  4701.    * @param {string=} mimeType
  4702.    * @return {!Promise.<shaka.extern.Track>}
  4703.    * @export
  4704.    */
  4705.   async addThumbnailsTrack(uri, mimeType) {
  4706.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
  4707.         this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
  4708.       shaka.log.error(
  4709.           'Must call load() and wait for it to resolve before adding image ' +
  4710.           'tracks.');
  4711.       throw new shaka.util.Error(
  4712.           shaka.util.Error.Severity.RECOVERABLE,
  4713.           shaka.util.Error.Category.PLAYER,
  4714.           shaka.util.Error.Code.CONTENT_NOT_LOADED);
  4715.     }
  4717.     if (!mimeType) {
  4718.       mimeType = await this.getTextMimetype_(uri);
  4719.     }
  4721.     if (mimeType != 'text/vtt') {
  4722.       throw new shaka.util.Error(
  4723.           shaka.util.Error.Severity.RECOVERABLE,
  4724.           shaka.util.Error.Category.TEXT,
  4725.           shaka.util.Error.Code.UNSUPPORTED_EXTERNAL_THUMBNAILS_URI,
  4726.           uri);
  4727.     }
  4729.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  4730.     let duration = this.video_.duration;
  4731.     if (this.manifest_) {
  4732.       duration = this.manifest_.presentationTimeline.getDuration();
  4733.     }
  4734.     if (duration == Infinity) {
  4735.       throw new shaka.util.Error(
  4736.           shaka.util.Error.Severity.RECOVERABLE,
  4737.           shaka.util.Error.Category.MANIFEST,
  4738.           shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_LIVE_STREAM);
  4739.     }
  4741.     goog.asserts.assert(
  4742.         this.networkingEngine_, 'Need networking engine.');
  4743.     const buffer = await this.getTextData_(uri,
  4744.         this.networkingEngine_,
  4745.         this.config_.streaming.retryParameters);
  4747.     const factory = shaka.text.TextEngine.findParser(mimeType);
  4748.     if (!factory) {
  4749.       throw new shaka.util.Error(
  4750.           shaka.util.Error.Severity.CRITICAL,
  4751.           shaka.util.Error.Category.TEXT,
  4752.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  4753.           mimeType);
  4754.     }
  4755.     const TextParser = factory();
  4756.     const time = {
  4757.       periodStart: 0,
  4758.       segmentStart: 0,
  4759.       segmentEnd: duration,
  4760.       vttOffset: 0,
  4761.     };
  4762.     const data = shaka.util.BufferUtils.toUint8(buffer);
  4763.     const cues = TextParser.parseMedia(data, time, uri);
  4765.     const references = [];
  4766.     for (const cue of cues) {
  4767.       const imageUri = shaka.util.ManifestParserUtils.resolveUris(
  4768.           [uri], [cue.payload])[0];
  4769.       const reference = new shaka.media.SegmentReference(
  4770.           cue.startTime,
  4771.           cue.endTime,
  4772.           () => [imageUri],
  4773.           /* startByte= */ 0,
  4774.           /* endByte= */ null,
  4775.           /* initSegmentReference= */ null,
  4776.           /* timestampOffset= */ 0,
  4777.           /* appendWindowStart= */ 0,
  4778.           /* appendWindowEnd= */ Infinity,
  4779.       );
  4780.       if (imageUri.includes('#xywh')) {
  4781.         const spriteInfo = imageUri.split('#xywh=')[1].split(',');
  4782.         if (spriteInfo.length === 4) {
  4783.           reference.setThumbnailSprite({
  4784.             height: parseInt(spriteInfo[3], 10),
  4785.             positionX: parseInt(spriteInfo[0], 10),
  4786.             positionY: parseInt(spriteInfo[1], 10),
  4787.             width: parseInt(spriteInfo[2], 10),
  4788.           });
  4789.         }
  4790.       }
  4791.       references.push(reference);
  4792.     }
  4794.     /** @type {shaka.extern.Stream} */
  4795.     const stream = {
  4796.       id: this.nextExternalStreamId_++,
  4797.       originalId: null,
  4798.       groupId: null,
  4799.       createSegmentIndex: () => Promise.resolve(),
  4800.       segmentIndex: new shaka.media.SegmentIndex(references),
  4801.       mimeType: mimeType || '',
  4802.       codecs: '',
  4803.       kind: '',
  4804.       encrypted: false,
  4805.       drmInfos: [],
  4806.       keyIds: new Set(),
  4807.       language: 'und',
  4808.       originalLanguage: null,
  4809.       label: null,
  4810.       type: ContentType.IMAGE,
  4811.       primary: false,
  4812.       trickModeVideo: null,
  4813.       emsgSchemeIdUris: null,
  4814.       roles: [],
  4815.       forced: false,
  4816.       channelsCount: null,
  4817.       audioSamplingRate: null,
  4818.       spatialAudio: false,
  4819.       closedCaptions: null,
  4820.       tilesLayout: '1x1',
  4821.       accessibilityPurpose: null,
  4822.       external: true,
  4823.       fastSwitching: false,
  4824.     };
  4826.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  4827.       this.externalSrcEqualsThumbnailsStreams_.push(stream);
  4828.     } else {
  4829.       this.manifest_.imageStreams.push(stream);
  4830.     }
  4831.     this.onTracksChanged_();
  4832.     return shaka.util.StreamUtils.imageStreamToTrack(stream);
  4833.   }
  4835.   /**
  4836.    * Adds the given chapters track to the loaded manifest.  <code>load()</code>
  4837.    * must resolve before calling.  The presentation must have a duration.
  4838.    *
  4839.    * This returns the created track.
  4840.    *
  4841.    * @param {string} uri
  4842.    * @param {string} language
  4843.    * @param {string=} mimeType
  4844.    * @return {!Promise.<shaka.extern.Track>}
  4845.    * @export
  4846.    */
  4847.   async addChaptersTrack(uri, language, mimeType) {
  4848.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
  4849.         this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
  4850.       shaka.log.error(
  4851.           'Must call load() and wait for it to resolve before adding ' +
  4852.           'chapters tracks.');
  4853.       throw new shaka.util.Error(
  4854.           shaka.util.Error.Severity.RECOVERABLE,
  4855.           shaka.util.Error.Category.PLAYER,
  4856.           shaka.util.Error.Code.CONTENT_NOT_LOADED);
  4857.     }
  4859.     if (!mimeType) {
  4860.       mimeType = await this.getTextMimetype_(uri);
  4861.     }
  4863.     let adCuePoints = [];
  4864.     if (this.adManager_) {
  4865.       adCuePoints = this.adManager_.getCuePoints();
  4866.     }
  4868.     /** @type {!HTMLTrackElement} */
  4869.     const trackElement = await this.addSrcTrackElement_(
  4870.         uri, language, /* kind= */ 'chapters', mimeType, /* label= */ '',
  4871.         adCuePoints);
  4873.     const chaptersTracks = this.getChaptersTracks();
  4874.     const chaptersTrack = chaptersTracks.find((t) => {
  4875.       return t.language == language;
  4876.     });
  4878.     if (chaptersTrack) {
  4879.       await new Promise((resolve, reject) => {
  4880.         // The chapter data isn't available until the 'load' event fires, and
  4881.         // that won't happen until the chapters track is activated by the
  4882.         // activateChaptersTrack_ method.
  4883.         this.loadEventManager_.listenOnce(trackElement, 'load', resolve);
  4884.         this.loadEventManager_.listenOnce(trackElement, 'error', (event) => {
  4885.           reject(new shaka.util.Error(
  4886.               shaka.util.Error.Severity.RECOVERABLE,
  4887.               shaka.util.Error.Category.TEXT,
  4888.               shaka.util.Error.Code.CHAPTERS_TRACK_FAILED));
  4889.         });
  4890.       });
  4892.       this.onTracksChanged_();
  4894.       return chaptersTrack;
  4895.     }
  4897.     // This should not happen, but there are browser implementations that may
  4898.     // not support the Track element.
  4899.     shaka.log.error('Cannot add this text when loaded with src=');
  4900.     throw new shaka.util.Error(
  4901.         shaka.util.Error.Severity.RECOVERABLE,
  4902.         shaka.util.Error.Category.TEXT,
  4903.         shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_SRC_EQUALS);
  4904.   }
  4906.   /**
  4907.    * @param {string} uri
  4908.    * @return {!Promise.<string>}
  4909.    * @private
  4910.    */
  4911.   async getTextMimetype_(uri) {
  4912.     let mimeType;
  4913.     try {
  4914.       goog.asserts.assert(
  4915.           this.networkingEngine_, 'Need networking engine.');
  4916.       // eslint-disable-next-line require-atomic-updates
  4917.       mimeType = await shaka.net.NetworkingUtils.getMimeType(uri,
  4918.           this.networkingEngine_,
  4919.           this.config_.streaming.retryParameters);
  4920.     } catch (error) {}
  4922.     if (mimeType) {
  4923.       return mimeType;
  4924.     }
  4926.     shaka.log.error(
  4927.         'The mimeType has not been provided and it could not be deduced ' +
  4928.         'from its uri.');
  4929.     throw new shaka.util.Error(
  4930.         shaka.util.Error.Severity.RECOVERABLE,
  4931.         shaka.util.Error.Category.TEXT,
  4932.         shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
  4933.         uri);
  4934.   }
  4936.   /**
  4937.    * @param {string} uri
  4938.    * @param {string} language
  4939.    * @param {string} kind
  4940.    * @param {string} mimeType
  4941.    * @param {string} label
  4942.    * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
  4943.    * @return {!Promise.<!HTMLTrackElement>}
  4944.    * @private
  4945.    */
  4946.   async addSrcTrackElement_(uri, language, kind, mimeType, label,
  4947.       adCuePoints) {
  4948.     if (mimeType != 'text/vtt' || adCuePoints.length) {
  4949.       goog.asserts.assert(
  4950.           this.networkingEngine_, 'Need networking engine.');
  4951.       const data = await this.getTextData_(uri,
  4952.           this.networkingEngine_,
  4953.           this.config_.streaming.retryParameters);
  4954.       const vvtText = this.convertToWebVTT_(data, mimeType, adCuePoints);
  4955.       const blob = new Blob([vvtText], {type: 'text/vtt'});
  4956.       uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
  4957.       mimeType = 'text/vtt';
  4958.     }
  4960.     const trackElement =
  4961.       /** @type {!HTMLTrackElement} */(document.createElement('track'));
  4962.     trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
  4963.     trackElement.label = label;
  4964.     trackElement.kind = kind;
  4965.     trackElement.srclang = language;
  4967.     // Because we're pulling in the text track file via Javascript, the
  4968.     // same-origin policy applies. If you'd like to have a player served
  4969.     // from one domain, but the text track served from another, you'll
  4970.     // need to enable CORS in order to do so. In addition to enabling CORS
  4971.     // on the server serving the text tracks, you will need to add the
  4972.     // crossorigin attribute to the video element itself.
  4973.     if (!this.video_.getAttribute('crossorigin')) {
  4974.       this.video_.setAttribute('crossorigin', 'anonymous');
  4975.     }
  4977.     this.video_.appendChild(trackElement);
  4978.     return trackElement;
  4979.   }
  4981.   /**
  4982.    * @param {string} uri
  4983.    * @param {!shaka.net.NetworkingEngine} netEngine
  4984.    * @param {shaka.extern.RetryParameters} retryParams
  4985.    * @return {!Promise.<BufferSource>}
  4986.    * @private
  4987.    */
  4988.   async getTextData_(uri, netEngine, retryParams) {
  4989.     const type = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  4991.     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
  4992.     request.method = 'GET';
  4994.     this.cmcdManager_.applyTextData(request);
  4996.     const response = await netEngine.request(type, request).promise;
  4998.     return response.data;
  4999.   }
  5002.   /**
  5003.    * Converts an input string to a WebVTT format string.
  5004.    *
  5005.    * @param {BufferSource} buffer
  5006.    * @param {string} mimeType
  5007.    * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
  5008.    * @return {string}
  5009.    * @private
  5010.    */
  5011.   convertToWebVTT_(buffer, mimeType, adCuePoints) {
  5012.     const factory = shaka.text.TextEngine.findParser(mimeType);
  5013.     if (factory) {
  5014.       const obj = factory();
  5015.       const time = {
  5016.         periodStart: 0,
  5017.         segmentStart: 0,
  5018.         segmentEnd: this.video_.duration,
  5019.         vttOffset: 0,
  5020.       };
  5021.       const data = shaka.util.BufferUtils.toUint8(buffer);
  5022.       const cues = obj.parseMedia(data, time, /* uri= */ null);
  5023.       return shaka.text.WebVttGenerator.convert(cues, adCuePoints);
  5024.     }
  5025.     throw new shaka.util.Error(
  5026.         shaka.util.Error.Severity.CRITICAL,
  5027.         shaka.util.Error.Category.TEXT,
  5028.         shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  5029.         mimeType);
  5030.   }
  5032.   /**
  5033.    * Set the maximum resolution that the platform's hardware can handle.
  5034.    * This will be called automatically by <code>shaka.cast.CastReceiver</code>
  5035.    * to enforce limitations of the Chromecast hardware.
  5036.    *
  5037.    * @param {number} width
  5038.    * @param {number} height
  5039.    * @export
  5040.    */
  5041.   setMaxHardwareResolution(width, height) {
  5042.     this.maxHwRes_.width = width;
  5043.     this.maxHwRes_.height = height;
  5044.   }
  5046.   /**
  5047.    * Retry streaming after a streaming failure has occurred. When the player has
  5048.    * not loaded content or is loading content, this will be a no-op and will
  5049.    * return <code>false</code>.
  5050.    *
  5051.    * <p>
  5052.    * If the player has loaded content, and streaming has not seen an error, this
  5053.    * will return <code>false</code>.
  5054.    *
  5055.    * <p>
  5056.    * If the player has loaded content, and streaming seen an error, but the
  5057.    * could not resume streaming, this will return <code>false</code>.
  5058.    *
  5059.    * @param {number=} retryDelaySeconds
  5060.    * @return {boolean}
  5061.    * @export
  5062.    */
  5063.   retryStreaming(retryDelaySeconds = 0.1) {
  5064.     return this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE ?
  5065.            this.streamingEngine_.retry(retryDelaySeconds) :
  5066.            false;
  5067.   }
  5069.   /**
  5070.    * Get the manifest that the player has loaded. If the player has not loaded
  5071.    * any content, this will return <code>null</code>.
  5072.    *
  5073.    * NOTE: This structure is NOT covered by semantic versioning compatibility
  5074.    * guarantees.  It may change at any time!
  5075.    *
  5076.    * This is marked as deprecated to warn Closure Compiler users at compile-time
  5077.    * to avoid using this method.
  5078.    *
  5079.    * @return {?shaka.extern.Manifest}
  5080.    * @export
  5081.    * @deprecated
  5082.    */
  5083.   getManifest() {
  5084.     shaka.log.alwaysWarn(
  5085.         'Shaka Player\'s internal Manifest structure is NOT covered by ' +
  5086.         'semantic versioning compatibility guarantees.  It may change at any ' +
  5087.         'time!  Please consider filing a feature request for whatever you ' +
  5088.         'use getManifest() for.');
  5089.     return this.manifest_;
  5090.   }
  5092.   /**
  5093.    * Get the type of manifest parser that the player is using. If the player has
  5094.    * not loaded any content, this will return <code>null</code>.
  5095.    *
  5096.    * @return {?shaka.extern.ManifestParser.Factory}
  5097.    * @export
  5098.    */
  5099.   getManifestParserFactory() {
  5100.     return this.parserFactory_;
  5101.   }
  5103.   /**
  5104.    * @param {shaka.extern.Variant} variant
  5105.    * @param {boolean} fromAdaptation
  5106.    * @private
  5107.    */
  5108.   addVariantToSwitchHistory_(variant, fromAdaptation) {
  5109.     const switchHistory = this.stats_.getSwitchHistory();
  5110.     switchHistory.updateCurrentVariant(variant, fromAdaptation);
  5111.   }
  5113.   /**
  5114.    * @param {shaka.extern.Stream} textStream
  5115.    * @param {boolean} fromAdaptation
  5116.    * @private
  5117.    */
  5118.   addTextStreamToSwitchHistory_(textStream, fromAdaptation) {
  5119.     const switchHistory = this.stats_.getSwitchHistory();
  5120.     switchHistory.updateCurrentText(textStream, fromAdaptation);
  5121.   }
  5123.   /**
  5124.    * @return {shaka.extern.PlayerConfiguration}
  5125.    * @private
  5126.    */
  5127.   defaultConfig_() {
  5128.     const config = shaka.util.PlayerConfiguration.createDefault();
  5130.     config.streaming.failureCallback = (error) => {
  5131.       this.defaultStreamingFailureCallback_(error);
  5132.     };
  5134.     // Because this.video_ may not be set when the config is built, the default
  5135.     // TextDisplay factory must capture a reference to "this".
  5136.     config.textDisplayFactory = () => {
  5137.       if (this.videoContainer_) {
  5138.         return new shaka.text.UITextDisplayer(
  5139.             this.video_, this.videoContainer_);
  5140.       } else {
  5141.         // eslint-disable-next-line no-restricted-syntax
  5142.         if (HTMLMediaElement.prototype.addTextTrack) {
  5143.           return new shaka.text.SimpleTextDisplayer(this.video_);
  5144.         } else {
  5145.           shaka.log.warning('Text tracks are not supported by the ' +
  5146.                             'browser, disabling.');
  5147.           return new shaka.text.StubTextDisplayer();
  5148.         }
  5149.       }
  5150.     };
  5151.     return config;
  5152.   }
  5154.   /**
  5155.    * Set the videoContainer to construct UITextDisplayer.
  5156.    * @param {HTMLElement} videoContainer
  5157.    * @export
  5158.    */
  5159.   setVideoContainer(videoContainer) {
  5160.     this.videoContainer_ = videoContainer;
  5161.   }
  5163.   /**
  5164.    * @param {!shaka.util.Error} error
  5165.    * @private
  5166.    */
  5167.   defaultStreamingFailureCallback_(error) {
  5168.     // For live streams, we retry streaming automatically for certain errors.
  5169.     // For VOD streams, all streaming failures are fatal.
  5170.     if (!this.isLive()) {
  5171.       return;
  5172.     }
  5174.     let retryDelaySeconds = null;
  5175.     if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS ||
  5176.         error.code == shaka.util.Error.Code.HTTP_ERROR) {
  5177.       // These errors can be near-instant, so delay a bit before retrying.
  5178.       retryDelaySeconds = 1;
  5179.     } else if (error.code == shaka.util.Error.Code.TIMEOUT) {
  5180.       // We already waited for a timeout, so retry quickly.
  5181.       retryDelaySeconds = 0.1;
  5182.     }
  5184.     if (retryDelaySeconds != null) {
  5185.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  5186.       shaka.log.warning('Live streaming error.  Retrying automatically...');
  5187.       this.retryStreaming(retryDelaySeconds);
  5188.     }
  5189.   }
  5191.   /**
  5192.    * For CEA closed captions embedded in the video streams, create dummy text
  5193.    * stream.  This can be safely called again on existing manifests, for
  5194.    * manifest updates.
  5195.    * @param {!shaka.extern.Manifest} manifest
  5196.    * @private
  5197.    */
  5198.   makeTextStreamsForClosedCaptions_(manifest) {
  5199.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  5200.     const TextStreamKind = shaka.util.ManifestParserUtils.TextStreamKind;
  5201.     const CEA608_MIME = shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
  5202.     const CEA708_MIME = shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE;
  5204.     // A set, to make sure we don't create two text streams for the same video.
  5205.     const closedCaptionsSet = new Set();
  5206.     for (const textStream of manifest.textStreams) {
  5207.       if (textStream.mimeType == CEA608_MIME ||
  5208.           textStream.mimeType == CEA708_MIME) {
  5209.         // This function might be called on a manifest update, so don't make a
  5210.         // new text stream for closed caption streams we have seen before.
  5211.         closedCaptionsSet.add(textStream.originalId);
  5212.       }
  5213.     }
  5214.     for (const variant of manifest.variants) {
  5215.       const video = variant.video;
  5216.       if (video && video.closedCaptions) {
  5217.         for (const id of video.closedCaptions.keys()) {
  5218.           if (!closedCaptionsSet.has(id)) {
  5219.             const mimeType = id.startsWith('CC') ? CEA608_MIME : CEA708_MIME;
  5221.             // Add an empty segmentIndex, for the benefit of the period combiner
  5222.             // in our builtin DASH parser.
  5223.             const segmentIndex = new shaka.media.MetaSegmentIndex();
  5224.             const language = video.closedCaptions.get(id);
  5225.             const textStream = {
  5226.               id: this.nextExternalStreamId_++,  // A globally unique ID.
  5227.               originalId: id, // The CC ID string, like 'CC1', 'CC3', etc.
  5228.               groupId: null,
  5229.               createSegmentIndex: () => Promise.resolve(),
  5230.               segmentIndex,
  5231.               mimeType,
  5232.               codecs: '',
  5233.               kind: TextStreamKind.CLOSED_CAPTION,
  5234.               encrypted: false,
  5235.               drmInfos: [],
  5236.               keyIds: new Set(),
  5237.               language,
  5238.               originalLanguage: language,
  5239.               label: null,
  5240.               type: ContentType.TEXT,
  5241.               primary: false,
  5242.               trickModeVideo: null,
  5243.               emsgSchemeIdUris: null,
  5244.               roles: video.roles,
  5245.               forced: false,
  5246.               channelsCount: null,
  5247.               audioSamplingRate: null,
  5248.               spatialAudio: false,
  5249.               closedCaptions: null,
  5250.               accessibilityPurpose: null,
  5251.               external: false,
  5252.               fastSwitching: false,
  5253.             };
  5254.             manifest.textStreams.push(textStream);
  5255.             closedCaptionsSet.add(id);
  5256.           }
  5257.         }
  5258.       }
  5259.     }
  5260.   }
  5262.   /**
  5263.    * Filters a manifest, removing unplayable streams/variants.
  5264.    *
  5265.    * @param {?shaka.extern.Manifest} manifest
  5266.    * @private
  5267.    */
  5268.   async filterManifest_(manifest) {
  5269.     await this.filterManifestWithStreamUtils_(manifest);
  5270.     this.filterManifestWithRestrictions_(manifest);
  5271.   }
  5273.   /**
  5274.    * Filters a manifest, removing unplayable streams/variants.
  5275.    *
  5276.    * @param {?shaka.extern.Manifest} manifest
  5277.    * @private
  5278.    */
  5279.   async filterManifestWithStreamUtils_(manifest) {
  5280.     goog.asserts.assert(manifest, 'Manifest should exist!');
  5281.     await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest);
  5282.     this.checkPlayableVariants_(manifest);
  5283.   }
  5286.   /**
  5287.    * Apply the restrictions configuration to the manifest, and check if there's
  5288.    * a variant that meets the restrictions.
  5289.    *
  5290.    * @param {?shaka.extern.Manifest} manifest
  5291.    * @private
  5292.    */
  5293.   filterManifestWithRestrictions_(manifest) {
  5294.     // Return if |destroy| is called.
  5295.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  5296.       return;
  5297.     }
  5298.     const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
  5299.         manifest.variants, this.config_.restrictions, this.maxHwRes_);
  5300.     if (tracksChanged && this.streamingEngine_) {
  5301.       this.onTracksChanged_();
  5302.     }
  5304.     // We may need to create new sessions for any new init data.
  5305.     const currentDrmInfo =
  5306.         this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  5307.     // DrmEngine.newInitData() requires mediaKeys to be available.
  5308.     if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
  5309.       for (const variant of manifest.variants) {
  5310.         this.processDrmInfos_(currentDrmInfo.keySystem, variant.video);
  5311.         this.processDrmInfos_(currentDrmInfo.keySystem, variant.audio);
  5312.       }
  5313.     }
  5314.     this.checkRestrictedVariants_(manifest);
  5315.   }
  5317.   /**
  5318.    * @param {string} keySystem
  5319.    * @param {?shaka.extern.Stream} stream
  5320.    * @private
  5321.    */
  5322.   processDrmInfos_(keySystem, stream) {
  5323.     if (!stream) {
  5324.       return;
  5325.     }
  5327.     for (const drmInfo of stream.drmInfos) {
  5328.       // Ignore any data for different key systems.
  5329.       if (drmInfo.keySystem == keySystem) {
  5330.         for (const initData of (drmInfo.initData || [])) {
  5331.           this.drmEngine_.newInitData(
  5332.               initData.initDataType, initData.initData);
  5333.         }
  5334.       }
  5335.     }
  5336.   }
  5338.   /**
  5339.    * @param {shaka.extern.Variant} initialVariant
  5340.    * @param {number} time
  5341.    * @return {!Promise.<number>}
  5342.    * @private
  5343.    */
  5344.   async adjustStartTime_(initialVariant, time) {
  5345.     /** @type {?shaka.extern.Stream} */
  5346.     const activeAudio = initialVariant.audio;
  5347.     /** @type {?shaka.extern.Stream} */
  5348.     const activeVideo = initialVariant.video;
  5350.     /**
  5351.      * @param {?shaka.extern.Stream} stream
  5352.      * @param {number} time
  5353.      * @return {!Promise.<?number>}
  5354.      */
  5355.     const getAdjustedTime = async (stream, time) => {
  5356.       if (!stream) {
  5357.         return null;
  5358.       }
  5360.       await stream.createSegmentIndex();
  5361.       const iter = stream.segmentIndex.getIteratorForTime(time);
  5362.       const ref = iter ? iter.next().value : null;
  5363.       if (!ref) {
  5364.         return null;
  5365.       }
  5367.       const refTime = ref.startTime;
  5368.       goog.asserts.assert(refTime <= time,
  5369.           'Segment should start before target time!');
  5370.       return refTime;
  5371.     };
  5373.     const audioStartTime = await getAdjustedTime(activeAudio, time);
  5374.     const videoStartTime = await getAdjustedTime(activeVideo, time);
  5376.     // If we have both video and audio times, pick the larger one.  If we picked
  5377.     // the smaller one, that one will download an entire segment to buffer the
  5378.     // difference.
  5379.     if (videoStartTime != null && audioStartTime != null) {
  5380.       return Math.max(videoStartTime, audioStartTime);
  5381.     } else if (videoStartTime != null) {
  5382.       return videoStartTime;
  5383.     } else if (audioStartTime != null) {
  5384.       return audioStartTime;
  5385.     } else {
  5386.       return time;
  5387.     }
  5388.   }
  5390.   /**
  5391.    * Update the buffering state to be either "we are buffering" or "we are not
  5392.    * buffering", firing events to the app as needed.
  5393.    *
  5394.    * @private
  5395.    */
  5396.   updateBufferState_() {
  5397.     const isBuffering = this.isBuffering();
  5398.     shaka.log.v2('Player changing buffering state to', isBuffering);
  5400.     // Make sure we have all the components we need before we consider ourselves
  5401.     // as being loaded.
  5402.     // TODO: Make the check for "loaded" simpler.
  5403.     const loaded = this.stats_ && this.bufferObserver_ && this.playhead_;
  5405.     if (loaded) {
  5406.       if (this.cmcdManager_) {
  5407.         this.cmcdManager_.setBuffering(isBuffering);
  5408.       }
  5409.       this.updateStateHistory_();
  5410.     }
  5412.     // Surface the buffering event so that the app knows if/when we are
  5413.     // buffering.
  5414.     const eventName = shaka.util.FakeEvent.EventName.Buffering;
  5415.     const data = (new Map()).set('buffering', isBuffering);
  5416.     this.dispatchEvent(this.makeEvent_(eventName, data));
  5417.   }
  5419.   /**
  5420.    * A callback for when the playback rate changes. We need to watch the
  5421.    * playback rate so that if the playback rate on the media element changes
  5422.    * (that was not caused by our play rate controller) we can notify the
  5423.    * controller so that it can stay in-sync with the change.
  5424.    *
  5425.    * @private
  5426.    */
  5427.   onRateChange_() {
  5428.     /** @type {number} */
  5429.     const newRate = this.video_.playbackRate;
  5431.     // On Edge, when someone seeks using the native controls, it will set the
  5432.     // playback rate to zero until they finish seeking, after which it will
  5433.     // return the playback rate.
  5434.     //
  5435.     // If the playback rate changes while seeking, Edge will cache the playback
  5436.     // rate and use it after seeking.
  5437.     //
  5438.     // https://github.com/shaka-project/shaka-player/issues/951
  5439.     if (newRate == 0) {
  5440.       return;
  5441.     }
  5443.     if (this.playRateController_) {
  5444.       // The playback rate has changed. This could be us or someone else.
  5445.       // If this was us, setting the rate again will be a no-op.
  5446.       this.playRateController_.set(newRate);
  5447.     }
  5449.     const event = this.makeEvent_(shaka.util.FakeEvent.EventName.RateChange);
  5450.     this.dispatchEvent(event);
  5451.   }
  5453.   /**
  5454.    * Try updating the state history. If the player has not finished
  5455.    * initializing, this will be a no-op.
  5456.    *
  5457.    * @private
  5458.    */
  5459.   updateStateHistory_() {
  5460.     // If we have not finish initializing, this will be a no-op.
  5461.     if (!this.stats_) {
  5462.       return;
  5463.     }
  5464.     if (!this.bufferObserver_) {
  5465.       return;
  5466.     }
  5468.     const State = shaka.media.BufferingObserver.State;
  5470.     const history = this.stats_.getStateHistory();
  5472.     let updateState = 'playing';
  5473.     if (this.bufferObserver_.getState() == State.STARVING) {
  5474.       updateState = 'buffering';
  5475.     } else if (this.video_.paused) {
  5476.       updateState = 'paused';
  5477.     } else if (this.video_.ended) {
  5478.       updateState = 'ended';
  5479.     }
  5480.     const stateChanged = history.update(updateState);
  5482.     if (stateChanged) {
  5483.       const eventName = shaka.util.FakeEvent.EventName.StateChanged;
  5484.       const data = (new Map()).set('newstate', updateState);
  5485.       this.dispatchEvent(this.makeEvent_(eventName, data));
  5486.     }
  5487.   }
  5489.   /**
  5490.    * Callback for liveSync
  5491.    *
  5492.    * @private
  5493.    */
  5494.   onTimeUpdate_() {
  5495.     // If the live stream has reached its end, do not sync.
  5496.     if (!this.isLive()) {
  5497.       return;
  5498.     }
  5499.     const seekRange = this.seekRange();
  5500.     if (!Number.isFinite(seekRange.end)) {
  5501.       return;
  5502.     }
  5503.     const currentTime = this.video_.currentTime;
  5504.     if (currentTime < seekRange.start) {
  5505.       // Bad stream?
  5506.       return;
  5507.     }
  5509.     let liveSyncMaxLatency;
  5510.     let liveSyncPlaybackRate;
  5511.     if (this.config_.streaming.liveSync) {
  5512.       liveSyncMaxLatency = this.config_.streaming.liveSyncMaxLatency;
  5513.       liveSyncPlaybackRate = this.config_.streaming.liveSyncPlaybackRate;
  5514.     } else {
  5515.       // serviceDescription must override if it is defined in the MPD and
  5516.       // liveSync configuration is not set.
  5517.       if (this.manifest_ && this.manifest_.serviceDescription) {
  5518.         liveSyncMaxLatency = this.manifest_.serviceDescription.maxLatency ||
  5519.           this.config_.streaming.liveSyncMaxLatency;
  5520.         liveSyncPlaybackRate =
  5521.           this.manifest_.serviceDescription.maxPlaybackRate ||
  5522.           this.config_.streaming.liveSyncPlaybackRate;
  5523.       }
  5524.     }
  5526.     let liveSyncMinLatency;
  5527.     let liveSyncMinPlaybackRate;
  5528.     if (this.config_.streaming.liveSync) {
  5529.       liveSyncMinLatency = this.config_.streaming.liveSyncMinLatency;
  5530.       liveSyncMinPlaybackRate = this.config_.streaming.liveSyncMinPlaybackRate;
  5531.     } else {
  5532.       // serviceDescription must override if it is defined in the MPD and
  5533.       // liveSync configuration is not set.
  5534.       if (this.manifest_ && this.manifest_.serviceDescription) {
  5535.         liveSyncMinLatency = this.manifest_.serviceDescription.minLatency ||
  5536.           this.config_.streaming.liveSyncMinLatency;
  5537.         liveSyncMinPlaybackRate =
  5538.           this.manifest_.serviceDescription.minPlaybackRate ||
  5539.           this.config_.streaming.liveSyncMinPlaybackRate;
  5540.       }
  5541.     }
  5543.     const playbackRate = this.video_.playbackRate;
  5544.     const latency = seekRange.end - this.video_.currentTime;
  5545.     let offset = 0;
  5546.     // In src= mode, the seek range isn't updated frequently enough, so we need
  5547.     // to fudge the latency number with an offset.  The playback rate is used
  5548.     // as an offset, since that is the amount we catch up 1 second of
  5549.     // accelerated playback.
  5550.     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
  5551.       const buffered = this.video_.buffered;
  5552.       if (buffered.length > 0) {
  5553.         const bufferedEnd = buffered.end(buffered.length - 1);
  5554.         offset = Math.max(liveSyncPlaybackRate, bufferedEnd - seekRange.end);
  5555.       }
  5556.     }
  5558.     if (liveSyncMaxLatency && liveSyncPlaybackRate &&
  5559.         (latency - offset) > liveSyncMaxLatency) {
  5560.       if (playbackRate != liveSyncPlaybackRate) {
  5561.         shaka.log.debug('Latency (' + latency + 's) ' +
  5562.           'is greater than liveSyncMaxLatency (' + liveSyncMaxLatency + 's). ' +
  5563.           'Updating playbackRate to ' + liveSyncPlaybackRate);
  5564.         this.trickPlay(liveSyncPlaybackRate);
  5565.       }
  5566.     } else if (liveSyncMinLatency && liveSyncMinPlaybackRate &&
  5567.         (latency - offset) < liveSyncMinLatency) {
  5568.       if (playbackRate != liveSyncMinPlaybackRate) {
  5569.         shaka.log.debug('Latency (' + latency + 's) ' +
  5570.           'is smaller than liveSyncMinLatency (' + liveSyncMinLatency + 's). ' +
  5571.           'Updating playbackRate to ' + liveSyncMinPlaybackRate);
  5572.         this.trickPlay(liveSyncMinPlaybackRate);
  5573.       }
  5574.     } else if (playbackRate !== this.playRateController_.getDefaultRate()) {
  5575.       this.cancelTrickPlay();
  5576.     }
  5577.   }
  5579.   /**
  5580.    * Callback for video progress events
  5581.    *
  5582.    * @private
  5583.    */
  5584.   onVideoProgress_() {
  5585.     if (!this.video_) {
  5586.       return;
  5587.     }
  5588.     let hasNewCompletionPercent = false;
  5589.     const completionRatio = this.video_.currentTime / this.video_.duration;
  5590.     if (!isNaN(completionRatio)) {
  5591.       const percent = Math.round(100 * completionRatio);
  5592.       if (isNaN(this.completionPercent_)) {
  5593.         this.completionPercent_ = percent;
  5594.         hasNewCompletionPercent = true;
  5595.       } else {
  5596.         const newCompletionPercent = Math.max(this.completionPercent_, percent);
  5597.         if (this.completionPercent_ != newCompletionPercent) {
  5598.           this.completionPercent_ = newCompletionPercent;
  5599.           hasNewCompletionPercent = true;
  5600.         }
  5601.       }
  5602.     }
  5603.     if (hasNewCompletionPercent) {
  5604.       let event;
  5605.       if (this.completionPercent_ == 0) {
  5606.         event = this.makeEvent_(shaka.util.FakeEvent.EventName.Started);
  5607.       } else if (this.completionPercent_ == 25) {
  5608.         event = this.makeEvent_(shaka.util.FakeEvent.EventName.FirstQuartile);
  5609.       } else if (this.completionPercent_ == 50) {
  5610.         event = this.makeEvent_(shaka.util.FakeEvent.EventName.Midpoint);
  5611.       } else if (this.completionPercent_ == 75) {
  5612.         event = this.makeEvent_(shaka.util.FakeEvent.EventName.ThirdQuartile);
  5613.       } else if (this.completionPercent_ == 100) {
  5614.         event = this.makeEvent_(shaka.util.FakeEvent.EventName.Complete);
  5615.       }
  5616.       if (event) {
  5617.         this.dispatchEvent(event);
  5618.       }
  5619.     }
  5620.   }
  5622.   /**
  5623.    * Callback from Playhead.
  5624.    *
  5625.    * @private
  5626.    */
  5627.   onSeek_() {
  5628.     if (this.playheadObservers_) {
  5629.       this.playheadObservers_.notifyOfSeek();
  5630.     }
  5631.     if (this.streamingEngine_) {
  5632.       this.streamingEngine_.seeked();
  5633.     }
  5634.     if (this.bufferObserver_) {
  5635.       // If we seek into an unbuffered range, we should fire a 'buffering' event
  5636.       // immediately.  If StreamingEngine can buffer fast enough, we may not
  5637.       // update our buffering tracking otherwise.
  5638.       this.pollBufferState_();
  5639.     }
  5640.   }
  5642.   /**
  5643.    * Update AbrManager with variants while taking into account restrictions,
  5644.    * preferences, and ABR.
  5645.    *
  5646.    * On error, this dispatches an error event and returns false.
  5647.    *
  5648.    * @return {boolean} True if successful.
  5649.    * @private
  5650.    */
  5651.   updateAbrManagerVariants_() {
  5652.     try {
  5653.       goog.asserts.assert(this.manifest_, 'Manifest should exist by now!');
  5654.       this.checkRestrictedVariants_(this.manifest_);
  5655.     } catch (e) {
  5656.       this.onError_(e);
  5657.       return false;
  5658.     }
  5660.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  5661.         this.manifest_.variants);
  5663.     // Update the abr manager with newly filtered variants.
  5664.     const adaptationSet = this.currentAdaptationSetCriteria_.create(
  5665.         playableVariants);
  5666.     this.abrManager_.setVariants(Array.from(adaptationSet.values()));
  5667.     return true;
  5668.   }
  5670.   /**
  5671.    * Chooses a variant from all possible variants while taking into account
  5672.    * restrictions, preferences, and ABR.
  5673.    *
  5674.    * On error, this dispatches an error event and returns null.
  5675.    *
  5676.    * @param {boolean=} initialSelection
  5677.    * @return {?shaka.extern.Variant}
  5678.    * @private
  5679.    */
  5680.   chooseVariant_(initialSelection = false) {
  5681.     if (this.updateAbrManagerVariants_()) {
  5682.       return this.abrManager_.chooseVariant(initialSelection);
  5683.     } else {
  5684.       return null;
  5685.     }
  5686.   }
  5688.   /**
  5689.    * Checks to re-enable variants that were temporarily disabled due to network
  5690.    * errors. If any variants are enabled this way, a new variant may be chosen
  5691.    * for playback.
  5692.    * @private
  5693.    */
  5694.   checkVariants_() {
  5695.     goog.asserts.assert(this.manifest_, 'Should have manifest!');
  5697.     const now = Date.now() / 1000;
  5698.     let hasVariantUpdate = false;
  5700.     /** @type {function(shaka.extern.Variant):string} */
  5701.     const streamsAsString = (variant) => {
  5702.       let str = '';
  5703.       if (variant.video) {
  5704.         str += 'video:' + variant.video.id;
  5705.       }
  5706.       if (variant.audio) {
  5707.         str += str ? '&' : '';
  5708.         str += 'audio:' + variant.audio.id;
  5709.       }
  5710.       return str;
  5711.     };
  5713.     for (const variant of this.manifest_.variants) {
  5714.       if (variant.disabledUntilTime > 0 && variant.disabledUntilTime <= now) {
  5715.         variant.disabledUntilTime = 0;
  5716.         hasVariantUpdate = true;
  5718.         shaka.log.v2('Re-enabled variant with ' + streamsAsString(variant));
  5719.       }
  5720.     }
  5722.     const shouldStopTimer = this.manifest_.variants.every((variant) => {
  5723.       goog.asserts.assert(
  5724.           variant.disabledUntilTime >= 0,
  5725.           '|variant.disableTimeUntilTime| must always be >= 0');
  5726.       return variant.disabledUntilTime === 0;
  5727.     });
  5729.     if (shouldStopTimer) {
  5730.       this.checkVariantsTimer_.stop();
  5731.     }
  5733.     if (hasVariantUpdate) {
  5734.       // Reconsider re-enabled variant for ABR switching.
  5735.       this.chooseVariantAndSwitch_(
  5736.           /* clearBuffer= */ true, /* safeMargin= */ undefined,
  5737.           /* force= */ false, /* fromAdaptation= */ false);
  5738.     }
  5739.   }
  5741.   /**
  5742.    * Choose a text stream from all possible text streams while taking into
  5743.    * account user preference.
  5744.    *
  5745.    * @return {?shaka.extern.Stream}
  5746.    * @private
  5747.    */
  5748.   chooseTextStream_() {
  5749.     const subset = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  5750.         this.manifest_.textStreams,
  5751.         this.currentTextLanguage_,
  5752.         this.currentTextRole_,
  5753.         this.currentTextForced_);
  5754.     return subset[0] || null;
  5755.   }
  5757.   /**
  5758.    * Chooses a new Variant.  If the new variant differs from the old one, it
  5759.    * adds the new one to the switch history and switches to it.
  5760.    *
  5761.    * Called after a config change, a key status event, or an explicit language
  5762.    * change.
  5763.    *
  5764.    * @param {boolean=} clearBuffer Optional clear buffer or not when
  5765.    *  switch to new variant
  5766.    *  Defaults to true if not provided
  5767.    * @param {number=} safeMargin Optional amount of buffer (in seconds) to
  5768.    *   retain when clearing the buffer.
  5769.    *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
  5770.    * @private
  5771.    */
  5772.   chooseVariantAndSwitch_(clearBuffer = true, safeMargin = 0, force = false,
  5773.       fromAdaptation = true) {
  5774.     goog.asserts.assert(this.config_, 'Must not be destroyed');
  5776.     // Because we're running this after a config change (manual language
  5777.     // change) or a key status event, it is always okay to clear the buffer
  5778.     // here.
  5779.     const chosenVariant = this.chooseVariant_();
  5780.     if (chosenVariant) {
  5781.       this.switchVariant_(chosenVariant, fromAdaptation,
  5782.           clearBuffer, safeMargin, force);
  5783.     }
  5784.   }
  5786.   /**
  5787.    * @param {shaka.extern.Variant} variant
  5788.    * @param {boolean} fromAdaptation
  5789.    * @param {boolean} clearBuffer
  5790.    * @param {number} safeMargin
  5791.    * @param {boolean=} force
  5792.    * @private
  5793.    */
  5794.   switchVariant_(variant, fromAdaptation, clearBuffer, safeMargin,
  5795.       force = false) {
  5796.     const currentVariant = this.streamingEngine_.getCurrentVariant();
  5797.     if (variant == currentVariant) {
  5798.       shaka.log.debug('Variant already selected.');
  5799.       // If you want to clear the buffer, we force to reselect the same variant.
  5800.       // We don't need to reset the timestampOffset since it's the same variant,
  5801.       // so 'adaptation' isn't passed here.
  5802.       if (clearBuffer) {
  5803.         this.streamingEngine_.switchVariant(variant, clearBuffer, safeMargin,
  5804.             /* force= */ true);
  5805.       }
  5806.       return;
  5807.     }
  5809.     // Add entries to the history.
  5810.     this.addVariantToSwitchHistory_(variant, fromAdaptation);
  5811.     this.streamingEngine_.switchVariant(
  5812.         variant, clearBuffer, safeMargin, force,
  5813.         /* adaptation= */ fromAdaptation);
  5814.     let oldTrack = null;
  5815.     if (currentVariant) {
  5816.       oldTrack = shaka.util.StreamUtils.variantToTrack(currentVariant);
  5817.     }
  5818.     const newTrack = shaka.util.StreamUtils.variantToTrack(variant);
  5820.     if (fromAdaptation) {
  5821.       // Dispatch an 'adaptation' event
  5822.       this.onAdaptation_(oldTrack, newTrack);
  5823.     } else {
  5824.       // Dispatch a 'variantchanged' event
  5825.       this.onVariantChanged_(oldTrack, newTrack);
  5826.     }
  5827.   }
  5829.   /**
  5830.    * @param {AudioTrack} track
  5831.    * @private
  5832.    */
  5833.   switchHtml5Track_(track) {
  5834.     goog.asserts.assert(this.video_ && this.video_.audioTracks,
  5835.         'Video and video.audioTracks should not be null!');
  5836.     const audioTracks = Array.from(this.video_.audioTracks);
  5837.     const currentTrack = audioTracks.find((t) => t.enabled);
  5839.     // This will reset the "enabled" of other tracks to false.
  5840.     track.enabled = true;
  5842.     // AirPlay does not reset the "enabled" of other tracks to false, so
  5843.     // it must be changed by hand.
  5844.     if (track.id !== currentTrack.id) {
  5845.       currentTrack.enabled = false;
  5846.     }
  5848.     const oldTrack =
  5849.       shaka.util.StreamUtils.html5AudioTrackToTrack(currentTrack);
  5850.     const newTrack =
  5851.       shaka.util.StreamUtils.html5AudioTrackToTrack(track);
  5852.     this.onVariantChanged_(oldTrack, newTrack);
  5853.   }
  5855.   /**
  5856.    * Decide during startup if text should be streamed/shown.
  5857.    * @private
  5858.    */
  5859.   setInitialTextState_(initialVariant, initialTextStream) {
  5860.     // Check if we should show text (based on difference between audio and text
  5861.     // languages).
  5862.     if (initialTextStream) {
  5863.       if (initialVariant.audio && this.shouldInitiallyShowText_(
  5864.           initialVariant.audio, initialTextStream)) {
  5865.         this.isTextVisible_ = true;
  5866.       }
  5867.       if (this.isTextVisible_) {
  5868.         // If the cached value says to show text, then update the text displayer
  5869.         // since it defaults to not shown.
  5870.         this.mediaSourceEngine_.getTextDisplayer().setTextVisibility(true);
  5871.         goog.asserts.assert(this.shouldStreamText_(),
  5872.             'Should be streaming text');
  5873.       }
  5874.       this.onTextTrackVisibility_();
  5875.     } else {
  5876.       this.isTextVisible_ = false;
  5877.     }
  5878.   }
  5880.   /**
  5881.    * Check if we should show text on screen automatically.
  5882.    *
  5883.    * @param {shaka.extern.Stream} audioStream
  5884.    * @param {shaka.extern.Stream} textStream
  5885.    * @return {boolean}
  5886.    * @private
  5887.    */
  5888.   shouldInitiallyShowText_(audioStream, textStream) {
  5889.     const AutoShowText = shaka.config.AutoShowText;
  5891.     if (this.config_.autoShowText == AutoShowText.NEVER) {
  5892.       return false;
  5893.     }
  5894.     if (this.config_.autoShowText == AutoShowText.ALWAYS) {
  5895.       return true;
  5896.     }
  5898.     const LanguageUtils = shaka.util.LanguageUtils;
  5900.     /** @type {string} */
  5901.     const preferredTextLocale =
  5902.         LanguageUtils.normalize(this.config_.preferredTextLanguage);
  5903.     /** @type {string} */
  5904.     const textLocale = LanguageUtils.normalize(textStream.language);
  5906.     if (this.config_.autoShowText == AutoShowText.IF_PREFERRED_TEXT_LANGUAGE) {
  5907.       // Only the text language match matters.
  5908.       return LanguageUtils.areLanguageCompatible(
  5909.           textLocale,
  5910.           preferredTextLocale);
  5911.     }
  5913.     if (this.config_.autoShowText == AutoShowText.IF_SUBTITLES_MAY_BE_NEEDED) {
  5914.       /* The text should automatically be shown if the text is
  5915.        * language-compatible with the user's text language preference, but not
  5916.        * compatible with the audio.  These are cases where we deduce that
  5917.        * subtitles may be needed.
  5918.        *
  5919.        * For example:
  5920.        *   preferred | chosen | chosen |
  5921.        *   text      | text   | audio  | show
  5922.        *   -----------------------------------
  5923.        *   en-CA     | en     | jp     | true
  5924.        *   en        | en-US  | fr     | true
  5925.        *   fr-CA     | en-US  | jp     | false
  5926.        *   en-CA     | en-US  | en-US  | false
  5927.        *
  5928.        */
  5929.       /** @type {string} */
  5930.       const audioLocale = LanguageUtils.normalize(audioStream.language);
  5932.       return (
  5933.         LanguageUtils.areLanguageCompatible(textLocale, preferredTextLocale) &&
  5934.         !LanguageUtils.areLanguageCompatible(audioLocale, textLocale));
  5935.     }
  5937.     shaka.log.alwaysWarn('Invalid autoShowText setting!');
  5938.     return false;
  5939.   }
  5941.   /**
  5942.    * Callback from StreamingEngine.
  5943.    *
  5944.    * @private
  5945.    */
  5946.   onManifestUpdate_() {
  5947.     if (this.parser_ && this.parser_.update) {
  5948.       this.parser_.update();
  5949.     }
  5950.   }
  5952.   /**
  5953.    * Callback from StreamingEngine.
  5954.    *
  5955.    * @private
  5956.    */
  5957.   onSegmentAppended_(start, end, contentType) {
  5958.     // When we append a segment to media source (via streaming engine) we are
  5959.     // changing what data we have buffered, so notify the playhead of the
  5960.     // change.
  5961.     if (this.playhead_) {
  5962.       this.playhead_.notifyOfBufferingChange();
  5963.     }
  5964.     this.pollBufferState_();
  5966.     // Dispatch an event for users to consume, too.
  5967.     const data = new Map()
  5968.         .set('start', start)
  5969.         .set('end', end)
  5970.         .set('contentType', contentType);
  5971.     this.dispatchEvent(this.makeEvent_(
  5972.         shaka.util.FakeEvent.EventName.SegmentAppended, data));
  5973.   }
  5975.   /**
  5976.    * Callback from AbrManager.
  5977.    *
  5978.    * @param {shaka.extern.Variant} variant
  5979.    * @param {boolean=} clearBuffer
  5980.    * @param {number=} safeMargin Optional amount of buffer (in seconds) to
  5981.    *   retain when clearing the buffer.
  5982.    *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
  5983.    * @private
  5984.    */
  5985.   switch_(variant, clearBuffer = false, safeMargin = 0) {
  5986.     shaka.log.debug('switch_');
  5987.     goog.asserts.assert(this.config_.abr.enabled,
  5988.         'AbrManager should not call switch while disabled!');
  5989.     goog.asserts.assert(this.manifest_, 'We need a manifest to switch ' +
  5990.                                         'variants.');
  5992.     if (!this.streamingEngine_) {
  5993.       // There's no way to change it.
  5994.       return;
  5995.     }
  5997.     if (variant == this.streamingEngine_.getCurrentVariant()) {
  5998.       // This isn't a change.
  5999.       return;
  6000.     }
  6002.     this.switchVariant_(variant, /* fromAdaptation= */ true,
  6003.         clearBuffer, safeMargin);
  6004.   }
  6006.   /**
  6007.    * Dispatches an 'adaptation' event.
  6008.    * @param {?shaka.extern.Track} from
  6009.    * @param {shaka.extern.Track} to
  6010.    * @private
  6011.    */
  6012.   onAdaptation_(from, to) {
  6013.     // Delay the 'adaptation' event so that StreamingEngine has time to absorb
  6014.     // the changes before the user tries to query it.
  6015.     const data = new Map()
  6016.         .set('oldTrack', from)
  6017.         .set('newTrack', to);
  6018.     if (this.lcevcDec_) {
  6019.       this.lcevcDec_.updateVariant(to, this.getManifestType());
  6020.     }
  6021.     const event =
  6022.         this.makeEvent_(shaka.util.FakeEvent.EventName.Adaptation, data);
  6023.     this.delayDispatchEvent_(event);
  6024.   }
  6026.   /**
  6027.    * Dispatches a 'trackschanged' event.
  6028.    * @private
  6029.    */
  6030.   onTracksChanged_() {
  6031.     // Delay the 'trackschanged' event so StreamingEngine has time to absorb the
  6032.     // changes before the user tries to query it.
  6033.     const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TracksChanged);
  6034.     this.delayDispatchEvent_(event);
  6035.   }
  6037.   /**
  6038.    * Dispatches a 'variantchanged' event.
  6039.    * @param {?shaka.extern.Track} from
  6040.    * @param {shaka.extern.Track} to
  6041.    * @private
  6042.    */
  6043.   onVariantChanged_(from, to) {
  6044.     // Delay the 'variantchanged' event so StreamingEngine has time to absorb
  6045.     // the changes before the user tries to query it.
  6046.     const data = new Map()
  6047.         .set('oldTrack', from)
  6048.         .set('newTrack', to);
  6049.     if (this.lcevcDec_) {
  6050.       this.lcevcDec_.updateVariant(to, this.getManifestType());
  6051.     }
  6053.     const event =
  6054.         this.makeEvent_(shaka.util.FakeEvent.EventName.VariantChanged, data);
  6055.     this.delayDispatchEvent_(event);
  6056.   }
  6058.   /**
  6059.    * Dispatches a 'textchanged' event.
  6060.    * @private
  6061.    */
  6062.   onTextChanged_() {
  6063.     // Delay the 'textchanged' event so StreamingEngine time to absorb the
  6064.     // changes before the user tries to query it.
  6065.     const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TextChanged);
  6066.     this.delayDispatchEvent_(event);
  6067.   }
  6069.   /** @private */
  6070.   onTextTrackVisibility_() {
  6071.     const event =
  6072.         this.makeEvent_(shaka.util.FakeEvent.EventName.TextTrackVisibility);
  6073.     this.delayDispatchEvent_(event);
  6074.   }
  6076.   /** @private */
  6077.   onAbrStatusChanged_() {
  6078.     // Restore disabled variants if abr get disabled
  6079.     if (!this.config_.abr.enabled) {
  6080.       this.restoreDisabledVariants_();
  6081.     }
  6083.     const data = (new Map()).set('newStatus', this.config_.abr.enabled);
  6084.     this.delayDispatchEvent_(this.makeEvent_(
  6085.         shaka.util.FakeEvent.EventName.AbrStatusChanged, data));
  6086.   }
  6088.   /**
  6089.    * @param {boolean} updateAbrManager
  6090.    * @private
  6091.    */
  6092.   restoreDisabledVariants_(updateAbrManager=true) {
  6093.     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE) {
  6094.       return;
  6095.     }
  6096.     goog.asserts.assert(this.manifest_, 'Should have manifest!');
  6098.     shaka.log.v2('Restoring all disabled streams...');
  6100.     this.checkVariantsTimer_.stop();
  6102.     for (const variant of this.manifest_.variants) {
  6103.       variant.disabledUntilTime = 0;
  6104.     }
  6106.     if (updateAbrManager) {
  6107.       this.updateAbrManagerVariants_();
  6108.     }
  6109.   }
  6111.   /**
  6112.    * Temporarily disable all variants containing |stream|
  6113.    * @param {shaka.extern.Stream} stream
  6114.    * @param {number} disableTime
  6115.    * @return {boolean}
  6116.    */
  6117.   disableStream(stream, disableTime) {
  6118.     if (!this.config_.abr.enabled ||
  6119.         this.loadMode_ === shaka.Player.LoadMode.DESTROYED) {
  6120.       return false;
  6121.     }
  6123.     if (!navigator.onLine) {
  6124.       // Don't disable variants if we're completely offline, or else we end up
  6125.       // rapidly restricting all of them.
  6126.       return false;
  6127.     }
  6129.     // It only makes sense to disable a stream if we have an alternative else we
  6130.     // end up disabling all variants.
  6131.     const hasAltStream = this.manifest_.variants.some((variant) => {
  6132.       const altStream = variant[stream.type];
  6134.       if (altStream && altStream.id !== stream.id) {
  6135.         if (shaka.util.StreamUtils.isAudio(stream)) {
  6136.           return stream.language === altStream.language;
  6137.         }
  6138.         return true;
  6139.       }
  6140.       return false;
  6141.     });
  6143.     if (hasAltStream) {
  6144.       let didDisableStream = false;
  6146.       for (const variant of this.manifest_.variants) {
  6147.         const candidate = variant[stream.type];
  6149.         if (candidate && candidate.id === stream.id) {
  6150.           variant.disabledUntilTime = (Date.now() / 1000) + disableTime;
  6151.           didDisableStream = true;
  6153.           shaka.log.v2(
  6154.               'Disabled stream ' + stream.type + ':' + stream.id +
  6155.               ' for ' + disableTime + ' seconds...');
  6156.         }
  6157.       }
  6159.       goog.asserts.assert(didDisableStream, 'Must have disabled stream');
  6161.       this.checkVariantsTimer_.tickEvery(1);
  6163.       // Get the safeMargin to ensure a seamless playback
  6164.       const {video} = this.getBufferedInfo();
  6165.       const safeMargin =
  6166.           video.reduce((size, {start, end}) => size + end - start, 0);
  6168.       // Update abr manager variants and switch to recover playback
  6169.       this.chooseVariantAndSwitch_(
  6170.           /* clearBuffer= */ true, /* safeMargin= */ safeMargin,
  6171.           /* force= */ true, /* fromAdaptation= */ false);
  6172.       return true;
  6173.     }
  6175.     shaka.log.warning(
  6176.         'No alternate stream found for active ' + stream.type + ' stream. ' +
  6177.         'Will ignore request to disable stream...');
  6179.     return false;
  6180.   }
  6182.   /**
  6183.    * @param {!shaka.util.Error} error
  6184.    * @private
  6185.    */
  6186.   onError_(error) {
  6187.     goog.asserts.assert(error instanceof shaka.util.Error, 'Wrong error type!');
  6189.     // Errors dispatched after |destroy| is called are not meaningful and should
  6190.     // be safe to ignore.
  6191.     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
  6192.       return;
  6193.     }
  6195.     // Restore disabled variant if the player experienced a critical error.
  6196.     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
  6197.       this.restoreDisabledVariants_(/* updateAbrManager= */ false);
  6198.     }
  6200.     const eventName = shaka.util.FakeEvent.EventName.Error;
  6201.     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
  6202.     this.dispatchEvent(event);
  6203.     if (event.defaultPrevented) {
  6204.       error.handled = true;
  6205.     }
  6206.   }
  6208.   /**
  6209.    * When we fire region events, we need to copy the information out of the
  6210.    * region to break the connection with the player's internal data. We do the
  6211.    * copy here because this is the transition point between the player and the
  6212.    * app.
  6213.    *
  6214.    * @param {!shaka.util.FakeEvent.EventName} eventName
  6215.    * @param {shaka.extern.TimelineRegionInfo} region
  6216.    *
  6217.    * @private
  6218.    */
  6219.   onRegionEvent_(eventName, region) {
  6220.     // Always make a copy to avoid exposing our internal data to the app.
  6221.     const clone = {
  6222.       schemeIdUri: region.schemeIdUri,
  6223.       value: region.value,
  6224.       startTime: region.startTime,
  6225.       endTime: region.endTime,
  6226.       id: region.id,
  6227.       eventElement: region.eventElement,
  6228.     };
  6230.     const data = (new Map()).set('detail', clone);
  6231.     this.dispatchEvent(this.makeEvent_(eventName, data));
  6232.   }
  6234.   /**
  6235.    * When notified of a media quality change we need to emit a
  6236.    * MediaQualityChange event to the app.
  6237.    *
  6238.    * @param {shaka.extern.MediaQualityInfo} mediaQuality
  6239.    * @param {number} position
  6240.    *
  6241.    * @private
  6242.    */
  6243.   onMediaQualityChange_(mediaQuality, position) {
  6244.     // Always make a copy to avoid exposing our internal data to the app.
  6245.     const clone = {
  6246.       bandwidth: mediaQuality.bandwidth,
  6247.       audioSamplingRate: mediaQuality.audioSamplingRate,
  6248.       codecs: mediaQuality.codecs,
  6249.       contentType: mediaQuality.contentType,
  6250.       frameRate: mediaQuality.frameRate,
  6251.       height: mediaQuality.height,
  6252.       mimeType: mediaQuality.mimeType,
  6253.       channelsCount: mediaQuality.channelsCount,
  6254.       pixelAspectRatio: mediaQuality.pixelAspectRatio,
  6255.       width: mediaQuality.width,
  6256.     };
  6258.     const data = new Map()
  6259.         .set('mediaQuality', clone)
  6260.         .set('position', position);
  6262.     this.dispatchEvent(this.makeEvent_(
  6263.         shaka.util.FakeEvent.EventName.MediaQualityChanged, data));
  6264.   }
  6266.   /**
  6267.    * Turn the media element's error object into a Shaka Player error object.
  6268.    *
  6269.    * @return {shaka.util.Error}
  6270.    * @private
  6271.    */
  6272.   videoErrorToShakaError_() {
  6273.     goog.asserts.assert(this.video_.error,
  6274.         'Video error expected, but missing!');
  6275.     if (!this.video_.error) {
  6276.       return null;
  6277.     }
  6279.     const code = this.video_.error.code;
  6280.     if (code == 1 /* MEDIA_ERR_ABORTED */) {
  6281.       // Ignore this error code, which should only occur when navigating away or
  6282.       // deliberately stopping playback of HTTP content.
  6283.       return null;
  6284.     }
  6286.     // Extra error information from MS Edge:
  6287.     let extended = this.video_.error.msExtendedCode;
  6288.     if (extended) {
  6289.       // Convert to unsigned:
  6290.       if (extended < 0) {
  6291.         extended += Math.pow(2, 32);
  6292.       }
  6293.       // Format as hex:
  6294.       extended = extended.toString(16);
  6295.     }
  6297.     // Extra error information from Chrome:
  6298.     const message = this.video_.error.message;
  6300.     return new shaka.util.Error(
  6301.         shaka.util.Error.Severity.CRITICAL,
  6302.         shaka.util.Error.Category.MEDIA,
  6303.         shaka.util.Error.Code.VIDEO_ERROR,
  6304.         code, extended, message);
  6305.   }
  6307.   /**
  6308.    * @param {!Event} event
  6309.    * @private
  6310.    */
  6311.   onVideoError_(event) {
  6312.     const error = this.videoErrorToShakaError_();
  6313.     if (!error) {
  6314.       return;
  6315.     }
  6316.     this.onError_(error);
  6317.   }
  6319.   /**
  6320.    * @param {!Object.<string, string>} keyStatusMap A map of hex key IDs to
  6321.    *   statuses.
  6322.    * @private
  6323.    */
  6324.   onKeyStatus_(keyStatusMap) {
  6325.     if (!this.streamingEngine_) {
  6326.       // We can't use this info to manage restrictions in src= mode, so ignore
  6327.       // it.
  6328.       return;
  6329.     }
  6331.     const event =
  6332.         this.makeEvent_(shaka.util.FakeEvent.EventName.KeyStatusChanged);
  6333.     this.dispatchEvent(event);
  6335.     const keyIds = Object.keys(keyStatusMap);
  6336.     if (keyIds.length == 0) {
  6337.       shaka.log.warning(
  6338.           'Got a key status event without any key statuses, so we don\'t ' +
  6339.           'know the real key statuses. If we don\'t have all the keys, ' +
  6340.           'you\'ll need to set restrictions so we don\'t select those tracks.');
  6341.     }
  6343.     // If EME is using a synthetic key ID, the only key ID is '00' (a single 0
  6344.     // byte).  In this case, it is only used to report global success/failure.
  6345.     // See note about old platforms in: https://bit.ly/2tpez5Z
  6346.     const isGlobalStatus = keyIds.length == 1 && keyIds[0] == '00';
  6347.     if (isGlobalStatus) {
  6348.       shaka.log.warning(
  6349.           'Got a synthetic key status event, so we don\'t know the real key ' +
  6350.           'statuses. If we don\'t have all the keys, you\'ll need to set ' +
  6351.           'restrictions so we don\'t select those tracks.');
  6352.     }
  6354.     const restrictedStatuses = shaka.Player.restrictedStatuses_;
  6355.     let tracksChanged = false;
  6357.     // Only filter tracks for keys if we have some key statuses to look at.
  6358.     if (keyIds.length) {
  6359.       for (const variant of this.manifest_.variants) {
  6360.         const streams = shaka.util.StreamUtils.getVariantStreams(variant);
  6362.         for (const stream of streams) {
  6363.           const originalAllowed = variant.allowedByKeySystem;
  6365.           // Only update if we have key IDs for the stream.  If the keys aren't
  6366.           // all present, then the track should be restricted.
  6367.           if (stream.keyIds.size) {
  6368.             variant.allowedByKeySystem = true;
  6370.             for (const keyId of stream.keyIds) {
  6371.               const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
  6372.               variant.allowedByKeySystem = variant.allowedByKeySystem &&
  6373.                   !!keyStatus && !restrictedStatuses.includes(keyStatus);
  6374.             }
  6375.           }
  6377.           if (originalAllowed != variant.allowedByKeySystem) {
  6378.             tracksChanged = true;
  6379.           }
  6380.         }  // for (const stream of streams)
  6381.       }  // for (const variant of this.manifest_.variants)
  6382.     }  // if (keyIds.size)
  6384.     if (tracksChanged) {
  6385.       const variantsUpdated = this.updateAbrManagerVariants_();
  6386.       if (!variantsUpdated) {
  6387.         return;
  6388.       }
  6389.     }
  6391.     const currentVariant = this.streamingEngine_.getCurrentVariant();
  6392.     if (currentVariant && !currentVariant.allowedByKeySystem) {
  6393.       shaka.log.debug('Choosing new streams after key status changed');
  6394.       this.chooseVariantAndSwitch_();
  6395.     }
  6397.     if (tracksChanged) {
  6398.       this.onTracksChanged_();
  6399.     }
  6400.   }
  6402.   /**
  6403.    * Callback from DrmEngine
  6404.    * @param {string} keyId
  6405.    * @param {number} expiration
  6406.    * @private
  6407.    */
  6408.   onExpirationUpdated_(keyId, expiration) {
  6409.     if (this.parser_ && this.parser_.onExpirationUpdated) {
  6410.       this.parser_.onExpirationUpdated(keyId, expiration);
  6411.     }
  6413.     const event =
  6414.         this.makeEvent_(shaka.util.FakeEvent.EventName.ExpirationUpdated);
  6415.     this.dispatchEvent(event);
  6416.   }
  6418.   /**
  6419.    * @return {boolean} true if we should stream text right now.
  6420.    * @private
  6421.    */
  6422.   shouldStreamText_() {
  6423.     return this.config_.streaming.alwaysStreamText || this.isTextTrackVisible();
  6424.   }
  6426.   /**
  6427.    * Applies playRangeStart and playRangeEnd to the given timeline. This will
  6428.    * only affect non-live content.
  6429.    *
  6430.    * @param {shaka.media.PresentationTimeline} timeline
  6431.    * @param {number} playRangeStart
  6432.    * @param {number} playRangeEnd
  6433.    *
  6434.    * @private
  6435.    */
  6436.   static applyPlayRange_(timeline, playRangeStart, playRangeEnd) {
  6437.     if (playRangeStart > 0) {
  6438.       if (timeline.isLive()) {
  6439.         shaka.log.warning(
  6440.             '|playRangeStart| has been configured for live content. ' +
  6441.             'Ignoring the setting.');
  6442.       } else {
  6443.         timeline.setUserSeekStart(playRangeStart);
  6444.       }
  6445.     }
  6447.     // If the playback has been configured to end before the end of the
  6448.     // presentation, update the duration unless it's live content.
  6449.     const fullDuration = timeline.getDuration();
  6450.     if (playRangeEnd < fullDuration) {
  6451.       if (timeline.isLive()) {
  6452.         shaka.log.warning(
  6453.             '|playRangeEnd| has been configured for live content. ' +
  6454.             'Ignoring the setting.');
  6455.       } else {
  6456.         timeline.setDuration(playRangeEnd);
  6457.       }
  6458.     }
  6459.   }
  6461.   /**
  6462.    * Checks if the variants are all restricted, and throw an appropriate
  6463.    * exception if so.
  6464.    *
  6465.    * @param {shaka.extern.Manifest} manifest
  6466.    *
  6467.    * @private
  6468.    */
  6469.   checkRestrictedVariants_(manifest) {
  6470.     const restrictedStatuses = shaka.Player.restrictedStatuses_;
  6471.     const keyStatusMap =
  6472.         this.drmEngine_ ? this.drmEngine_.getKeyStatuses() : {};
  6473.     const keyIds = Object.keys(keyStatusMap);
  6474.     const isGlobalStatus = keyIds.length && keyIds[0] == '00';
  6476.     let hasPlayable = false;
  6477.     let hasAppRestrictions = false;
  6479.     /** @type {!Set.<string>} */
  6480.     const missingKeys = new Set();
  6482.     /** @type {!Set.<string>} */
  6483.     const badKeyStatuses = new Set();
  6485.     for (const variant of manifest.variants) {
  6486.       // TODO: Combine with onKeyStatus_.
  6487.       const streams = [];
  6488.       if (variant.audio) {
  6489.         streams.push(variant.audio);
  6490.       }
  6491.       if (variant.video) {
  6492.         streams.push(variant.video);
  6493.       }
  6495.       for (const stream of streams) {
  6496.         if (stream.keyIds.size) {
  6497.           for (const keyId of stream.keyIds) {
  6498.             const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
  6499.             if (!keyStatus) {
  6500.               missingKeys.add(keyId);
  6501.             } else if (restrictedStatuses.includes(keyStatus)) {
  6502.               badKeyStatuses.add(keyStatus);
  6503.             }
  6504.           }
  6505.         }  // if (stream.keyIds.size)
  6506.       }
  6508.       if (!variant.allowedByApplication) {
  6509.         hasAppRestrictions = true;
  6510.       } else if (variant.allowedByKeySystem) {
  6511.         hasPlayable = true;
  6512.       }
  6513.     }
  6515.     if (!hasPlayable) {
  6516.       /** @type {shaka.extern.RestrictionInfo} */
  6517.       const data = {
  6518.         hasAppRestrictions,
  6519.         missingKeys: Array.from(missingKeys),
  6520.         restrictedKeyStatuses: Array.from(badKeyStatuses),
  6521.       };
  6522.       throw new shaka.util.Error(
  6523.           shaka.util.Error.Severity.CRITICAL,
  6524.           shaka.util.Error.Category.MANIFEST,
  6525.           shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET,
  6526.           data);
  6527.     }
  6528.   }
  6530.   /**
  6531.    * Confirm some variants are playable. Otherwise, throw an exception.
  6532.    * @param {!shaka.extern.Manifest} manifest
  6533.    * @private
  6534.    */
  6535.   checkPlayableVariants_(manifest) {
  6536.     const valid = manifest.variants.some(shaka.util.StreamUtils.isPlayable);
  6538.     // If none of the variants are playable, throw
  6539.     // CONTENT_UNSUPPORTED_BY_BROWSER.
  6540.     if (!valid) {
  6541.       throw new shaka.util.Error(
  6542.           shaka.util.Error.Severity.CRITICAL,
  6543.           shaka.util.Error.Category.MANIFEST,
  6544.           shaka.util.Error.Code.CONTENT_UNSUPPORTED_BY_BROWSER);
  6545.     }
  6546.   }
  6548.   /**
  6549.    * Fire an event, but wait a little bit so that the immediate execution can
  6550.    * complete before the event is handled.
  6551.    *
  6552.    * @param {!shaka.util.FakeEvent} event
  6553.    * @private
  6554.    */
  6555.   async delayDispatchEvent_(event) {
  6556.     // Wait until the next interpreter cycle.
  6557.     await Promise.resolve();
  6559.     // Only dispatch the event if we are still alive.
  6560.     if (this.loadMode_ != shaka.Player.LoadMode.DESTROYED) {
  6561.       this.dispatchEvent(event);
  6562.     }
  6563.   }
  6565.   /**
  6566.    * Get the normalized languages for a group of tracks.
  6567.    *
  6568.    * @param {!Array.<?shaka.extern.Track>} tracks
  6569.    * @return {!Set.<string>}
  6570.    * @private
  6571.    */
  6572.   static getLanguagesFrom_(tracks) {
  6573.     const languages = new Set();
  6575.     for (const track of tracks) {
  6576.       if (track.language) {
  6577.         languages.add(shaka.util.LanguageUtils.normalize(track.language));
  6578.       } else {
  6579.         languages.add('und');
  6580.       }
  6581.     }
  6583.     return languages;
  6584.   }
  6586.   /**
  6587.    * Get all permutations of normalized languages and role for a group of
  6588.    * tracks.
  6589.    *
  6590.    * @param {!Array.<?shaka.extern.Track>} tracks
  6591.    * @return {!Array.<shaka.extern.LanguageRole>}
  6592.    * @private
  6593.    */
  6594.   static getLanguageAndRolesFrom_(tracks) {
  6595.     /** @type {!Map.<string, !Set>} */
  6596.     const languageToRoles = new Map();
  6597.     /** @type {!Map.<string, !Map.<string, string>>} */
  6598.     const languageRoleToLabel = new Map();
  6600.     for (const track of tracks) {
  6601.       let language = 'und';
  6602.       let roles = [];
  6604.       if (track.language) {
  6605.         language = shaka.util.LanguageUtils.normalize(track.language);
  6606.       }
  6608.       if (track.type == 'variant') {
  6609.         roles = track.audioRoles;
  6610.       } else {
  6611.         roles = track.roles;
  6612.       }
  6614.       if (!roles || !roles.length) {
  6615.         // We must have an empty role so that we will still get a language-role
  6616.         // entry from our Map.
  6617.         roles = [''];
  6618.       }
  6620.       if (!languageToRoles.has(language)) {
  6621.         languageToRoles.set(language, new Set());
  6622.       }
  6624.       for (const role of roles) {
  6625.         languageToRoles.get(language).add(role);
  6626.         if (track.label) {
  6627.           if (!languageRoleToLabel.has(language)) {
  6628.             languageRoleToLabel.set(language, new Map());
  6629.           }
  6630.           languageRoleToLabel.get(language).set(role, track.label);
  6631.         }
  6632.       }
  6633.     }
  6635.     // Flatten our map to an array of language-role pairs.
  6636.     const pairings = [];
  6637.     languageToRoles.forEach((roles, language) => {
  6638.       for (const role of roles) {
  6639.         let label = null;
  6640.         if (languageRoleToLabel.has(language) &&
  6641.             languageRoleToLabel.get(language).has(role)) {
  6642.           label = languageRoleToLabel.get(language).get(role);
  6643.         }
  6644.         pairings.push({language, role, label});
  6645.       }
  6646.     });
  6647.     return pairings;
  6648.   }
  6650.   /**
  6651.    * Assuming the player is playing content with media source, check if the
  6652.    * player has buffered enough content to make it to the end of the
  6653.    * presentation.
  6654.    *
  6655.    * @return {boolean}
  6656.    * @private
  6657.    */
  6658.   isBufferedToEndMS_() {
  6659.     goog.asserts.assert(
  6660.         this.video_,
  6661.         'We need a video element to get buffering information');
  6662.     goog.asserts.assert(
  6663.         this.mediaSourceEngine_,
  6664.         'We need a media source engine to get buffering information');
  6665.     goog.asserts.assert(
  6666.         this.manifest_,
  6667.         'We need a manifest to get buffering information');
  6669.     // This is a strong guarantee that we are buffered to the end, because it
  6670.     // means the playhead is already at that end.
  6671.     if (this.video_.ended) {
  6672.       return true;
  6673.     }
  6675.     // This means that MediaSource has buffered the final segment in all
  6676.     // SourceBuffers and is no longer accepting additional segments.
  6677.     if (this.mediaSourceEngine_.ended()) {
  6678.       return true;
  6679.     }
  6681.     // Live streams are "buffered to the end" when they have buffered to the
  6682.     // live edge or beyond (into the region covered by the presentation delay).
  6683.     if (this.manifest_.presentationTimeline.isLive()) {
  6684.       const liveEdge =
  6685.           this.manifest_.presentationTimeline.getSegmentAvailabilityEnd();
  6686.       const bufferEnd =
  6687.           shaka.media.TimeRangesUtils.bufferEnd(this.video_.buffered);
  6689.       if (bufferEnd != null && bufferEnd >= liveEdge) {
  6690.         return true;
  6691.       }
  6692.     }
  6694.     return false;
  6695.   }
  6697.   /**
  6698.    * Assuming the player is playing content with src=, check if the player has
  6699.    * buffered enough content to make it to the end of the presentation.
  6700.    *
  6701.    * @return {boolean}
  6702.    * @private
  6703.    */
  6704.   isBufferedToEndSrc_() {
  6705.     goog.asserts.assert(
  6706.         this.video_,
  6707.         'We need a video element to get buffering information');
  6709.     // This is a strong guarantee that we are buffered to the end, because it
  6710.     // means the playhead is already at that end.
  6711.     if (this.video_.ended) {
  6712.       return true;
  6713.     }
  6715.     // If we have buffered to the duration of the content, it means we will have
  6716.     // enough content to buffer to the end of the presentation.
  6717.     const bufferEnd =
  6718.         shaka.media.TimeRangesUtils.bufferEnd(this.video_.buffered);
  6720.     // Because Safari's native HLS reports slightly inaccurate values for
  6721.     // bufferEnd here, we use a fudge factor.  Without this, we can end up in a
  6722.     // buffering state at the end of the stream.  See issue #2117.
  6723.     const fudge = 1;  // 1000 ms
  6724.     return bufferEnd != null && bufferEnd >= this.video_.duration - fudge;
  6725.   }
  6727.   /**
  6728.    * Create an error for when we purposely interrupt a load operation.
  6729.    *
  6730.    * @return {!shaka.util.Error}
  6731.    * @private
  6732.    */
  6733.   createAbortLoadError_() {
  6734.     return new shaka.util.Error(
  6735.         shaka.util.Error.Severity.CRITICAL,
  6736.         shaka.util.Error.Category.PLAYER,
  6737.         shaka.util.Error.Code.LOAD_INTERRUPTED);
  6738.   }
  6739. };
  6741. /**
  6742.  * In order to know what method of loading the player used for some content, we
  6743.  * have this enum. It lets us know if content has not been loaded, loaded with
  6744.  * media source, or loaded with src equals.
  6745.  *
  6746.  * This enum has a low resolution, because it is only meant to express the
  6747.  * outer limits of the various states that the player is in. For example, when
  6748.  * someone calls a public method on player, it should not matter if they have
  6749.  * initialized drm engine, it should only matter if they finished loading
  6750.  * content.
  6751.  *
  6752.  * @enum {number}
  6753.  * @export
  6754.  */
  6755. shaka.Player.LoadMode = {
  6756.   'DESTROYED': 0,
  6757.   'NOT_LOADED': 1,
  6758.   'MEDIA_SOURCE': 2,
  6759.   'SRC_EQUALS': 3,
  6760. };
  6762. /**
  6763.  * The typical buffering threshold.  When we have less than this buffered (in
  6764.  * seconds), we enter a buffering state.  This specific value is based on manual
  6765.  * testing and evaluation across a variety of platforms.
  6766.  *
  6767.  * To make the buffering logic work in all cases, this "typical" threshold will
  6768.  * be overridden if the rebufferingGoal configuration is too low.
  6769.  *
  6770.  * @const {number}
  6771.  * @private
  6772.  */
  6773. shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  6775. /**
  6776.  * @define {string} A version number taken from git at compile time.
  6777.  * @export
  6778.  */
  6779. // eslint-disable-next-line no-useless-concat
  6780. shaka.Player.version = 'v4.6.0' + '-uncompiled';  // x-release-please-version
  6782. // Initialize the deprecation system using the version string we just set
  6783. // on the player.
  6784. shaka.Deprecate.init(shaka.Player.version);
  6787. /**
  6788.  * These are the EME key statuses that represent restricted playback.
  6789.  * 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
  6790.  * of the usable keys.  'expired' status is being handled separately in
  6791.  * DrmEngine.
  6792.  *
  6793.  * @const {!Array.<string>}
  6794.  * @private
  6795.  */
  6796. shaka.Player.restrictedStatuses_ = ['output-restricted', 'internal-error'];
  6799. /** @private {!Object.<string, function():*>} */
  6800. shaka.Player.supportPlugins_ = {};
  6803. /** @private {?shaka.extern.IAdManager.Factory} */
  6804. shaka.Player.adManagerFactory_ = null;
  6807. /**
  6808.  * @const {string}
  6809.  */
  6810. shaka.Player.TextTrackLabel = 'Shaka Player TextTrack';