shaka-player 4.4.3 → 4.6.0

package/lib/player.js

@@ -7,8 +7,8 @@
 goog.provide('shaka.Player');
 
 goog.require('goog.asserts');
-goog.require('shaka.Deprecate');
 goog.require('shaka.config.AutoShowText');
+goog.require('shaka.Deprecate');
 goog.require('shaka.log');
 goog.require('shaka.media.AdaptationSetCriteria');
 goog.require('shaka.media.BufferingObserver');
@@ -31,15 +31,16 @@ goog.require('shaka.media.SrcEqualsPlayhead');
 goog.require('shaka.media.StreamingEngine');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.net.NetworkingEngine');
-goog.require('shaka.routing.Walker');
+goog.require('shaka.net.NetworkingUtils');
 goog.require('shaka.text.SimpleTextDisplayer');
+goog.require('shaka.text.StubTextDisplayer');
 goog.require('shaka.text.TextEngine');
 goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
-goog.require('shaka.util.AbortableOperation');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.ConfigUtils');
+goog.require('shaka.util.Dom');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
@@ -49,6 +50,7 @@ goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MediaReadyState');
 goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.Mutex');
 goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PlayerConfiguration');
@@ -56,10 +58,8 @@ goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.Stats');
 goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.Timer');
-goog.require('shaka.lcevc.Dil');
+goog.require('shaka.lcevc.Dec');
 goog.requireType('shaka.media.PresentationTimeline');
-goog.requireType('shaka.routing.Node');
-goog.requireType('shaka.routing.Payload');
 
 
 /**
@@ -85,18 +85,6 @@ goog.requireType('shaka.routing.Payload');
  * @exportDoc
  */
 
-/**
- * @event shaka.Player.StateIdleEvent
- * @description Fired when the player has stopped changing states and will
- *    remain idle until a new state change request (e.g. <code>load</code>,
- *    <code>attach</code>, etc.) is made.
- * @property {string} type
- *    'onstateidle'
- * @property {string} state
- *    The name of the state that the player stopped in.
- * @exportDoc
- */
-
 /**
  * @event shaka.Player.EmsgEvent
  * @description Fired when an emsg box is found in a segment.
@@ -314,6 +302,18 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.ManifestUpdatedEvent
+ * @description Fired after the manifest has been updated (live streams).
+ * @property {string} type
+ *   'manifestupdated'
+ * @property {boolean} isLive
+ *   True when the playlist is live. Useful to detect transition from live
+ *   to static playlist..
+ * @exportDoc
+ */
+
+
 /**
  * @event shaka.Player.MetadataEvent
  * @description Triggers after metadata associated with the stream is found.
@@ -423,6 +423,76 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.KeyStatusChanged
+ * @description Fired when the key status changed.
+ * @property {string} type
+ *   'keystatuschanged'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.StateChanged
+ * @description Fired when player state is changed.
+ * @property {string} type
+ *   'statechanged'
+ * @property {string} newstate
+ *   The new state.
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.Started
+ * @description Fires when the content starts playing.
+ *     Only for VoD.
+ * @property {string} type
+ *   'started'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.FirstQuartile
+ * @description Fires when the content playhead crosses first quartile.
+ *     Only for VoD.
+ * @property {string} type
+ *   'firstquartile'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.Midpoint
+ * @description Fires when the content playhead crosses midpoint.
+ *     Only for VoD.
+ * @property {string} type
+ *   'midpoint'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.ThirdQuartile
+ * @description Fires when the content playhead crosses third quartile.
+ *     Only for VoD.
+ * @property {string} type
+ *   'thirdquartile'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.Complete
+ * @description Fires when the content completes playing.
+ *     Only for VoD.
+ * @property {string} type
+ *   'complete'
+ * @exportDoc
+ */
+
+
 /**
  * @summary The main player object for Shaka Player.
  *
@@ -491,6 +561,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.media.Playhead} */
     this.playhead_ = null;
 
+    /**
+     * Incremented whenever a top-level operation (load, attach, etc) is
+     * performed.
+     * Used to determine if a load operation has been interrupted.
+     * @private {number}
+     */
+    this.operationId_ = 0;
+
+    /** @private {!shaka.util.Mutex} */
+    this.mutex_ = new shaka.util.Mutex();
+
     /**
      * The playhead observers are used to monitor the position of the playhead
      * and some other source of data (e.g. buffered content), and raise events.
@@ -508,12 +589,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.playRateController_ = null;
 
-    // We use the buffering observer and timer to track when we move from having
-    // enough buffered content to not enough. They only exist when content has
-    // been loaded and are not re-used between loads.
-    /** @private {shaka.util.Timer} */
-    this.bufferPoller_ = null;
-
     /** @private {shaka.media.BufferingObserver} */
     this.bufferObserver_ = null;
 
@@ -528,9 +603,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {?HTMLCanvasElement} */
     this.lcevcCanvas_ = null;
 
-    // This is the LCEVC Dil object to decode LCEVC.
-    /** @private {?shaka.lcevc.Dil} */
-    this.lcevcDil_ = null;
+    // This is the LCEVC Decoder object to decode LCEVC.
+    /** @private {?shaka.lcevc.Dec} */
+    this.lcevcDec_ = null;
 
     /** @private {shaka.media.QualityObserver} */
     this.qualityObserver_ = null;
@@ -550,6 +625,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {?string} */
     this.assetUri_ = null;
 
+    /** @private {?number} */
+    this.startTime_ = null;
+
     /** @private {boolean} */
     this.fullyLoaded_ = false;
 
@@ -569,6 +647,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.nextExternalStreamId_ = 1e9;
 
+    /** @private {!Array.<shaka.extern.Stream>} */
+    this.externalSrcEqualsThumbnailsStreams_ = [];
+
+    /** @private {number} */
+    this.completionPercent_ = NaN;
+
     /** @private {?shaka.extern.PlayerConfiguration} */
     this.config_ = this.defaultConfig_();
 
@@ -591,7 +675,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             this.config_.preferredAudioLanguage,
             this.config_.preferredVariantRole,
             this.config_.preferredAudioChannelCount,
-            this.config_.preferredVideoHdrLevel);
+            this.config_.preferredVideoHdrLevel,
+            this.config_.preferredVideoLayout,
+            this.config_.preferredAudioLabel,
+            this.config_.mediaSource.codecSwitchingStrategy,
+            this.config_.manifest.dash.enableAudioGroups);
 
     /** @private {string} */
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
@@ -605,15 +693,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {!Array.<function():(!Promise|undefined)>} */
     this.cleanupOnUnload_ = [];
 
-    /**
-     * This playback start position will be used when
-     * <code>updateStartTime()</code> has been called to provide an updated
-     * start position during the media loading process.
-     *
-     * @private {?number}
-     */
-    this.updatedStartTime_ = null;
-
     if (dependencyInjector) {
       dependencyInjector(this);
     }
@@ -639,117 +718,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.retryStreaming();
     });
 
-    /** @private {shaka.routing.Node} */
-    this.detachNode_ = {name: 'detach'};
-    /** @private {shaka.routing.Node} */
-    this.attachNode_ = {name: 'attach'};
-    /** @private {shaka.routing.Node} */
-    this.unloadNode_ = {name: 'unload'};
-    /** @private {shaka.routing.Node} */
-    this.parserNode_ = {name: 'manifest-parser'};
-    /** @private {shaka.routing.Node} */
-    this.manifestNode_ = {name: 'manifest'};
-    /** @private {shaka.routing.Node} */
-    this.mediaSourceNode_ = {name: 'media-source'};
-    /** @private {shaka.routing.Node} */
-    this.drmNode_ = {name: 'drm-engine'};
-    /** @private {shaka.routing.Node} */
-    this.loadNode_ = {name: 'load'};
-    /** @private {shaka.routing.Node} */
-    this.srcEqualsDrmNode_ = {name: 'src-equals-drm-engine'};
-    /** @private {shaka.routing.Node} */
-    this.srcEqualsNode_ = {name: 'src-equals'};
-
-    const AbortableOperation = shaka.util.AbortableOperation;
-
-    const actions = new Map();
-    actions.set(this.attachNode_, (has, wants) => {
-      return AbortableOperation.notAbortable(this.onAttach_(has, wants));
-    });
-    actions.set(this.detachNode_, (has, wants) => {
-      return AbortableOperation.notAbortable(this.onDetach_(has, wants));
-    });
-    actions.set(this.unloadNode_, (has, wants) => {
-      return AbortableOperation.notAbortable(this.onUnload_(has, wants));
-    });
-    actions.set(this.mediaSourceNode_, (has, wants) => {
-      const p = this.onInitializeMediaSourceEngine_(has, wants);
-      return AbortableOperation.notAbortable(p);
-    });
-    actions.set(this.parserNode_, (has, wants) => {
-      const p = this.onInitializeParser_(has, wants);
-      return AbortableOperation.notAbortable(p);
-    });
-    actions.set(this.manifestNode_, (has, wants) => {
-      // This action is actually abortable, so unlike the other callbacks, this
-      // one will return an abortable operation.
-      return this.onParseManifest_(has, wants);
-    });
-    actions.set(this.drmNode_, (has, wants) => {
-      const p = this.onInitializeDrm_(has, wants);
-      return AbortableOperation.notAbortable(p);
-    });
-    actions.set(this.loadNode_, (has, wants) => {
-      return AbortableOperation.notAbortable(this.onLoad_(has, wants));
-    });
-
-    actions.set(this.srcEqualsDrmNode_, (has, wants) => {
-      const p = this.onInitializeSrcEqualsDrm_(has, wants);
-      return AbortableOperation.notAbortable(p);
-    });
-    actions.set(this.srcEqualsNode_, (has, wants) => {
-      return this.onSrcEquals_(has, wants);
-    });
-
-    /** @private {shaka.routing.Walker.Implementation} */
-    const walkerImplementation = {
-      getNext: (at, has, goingTo, wants) => {
-        return this.getNextStep_(at, has, goingTo, wants);
-      },
-      enterNode: (node, has, wants) => {
-        this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
-            /* data= */ (new Map()).set('state', node.name)));
-
-        const action = actions.get(node);
-        return action(has, wants);
-      },
-      handleError: async (has, error) => {
-        shaka.log.warning('The walker saw an error:');
-        if (error instanceof shaka.util.Error) {
-          shaka.log.warning('Error Code:', error.code);
-        } else {
-          shaka.log.warning('Error Message:', error.message);
-          shaka.log.warning('Error Stack:', error.stack);
-        }
-
-        // Regardless of what state we were in, if there is an error, we unload.
-        // This ensures that any initialized system will be torn-down and we
-        // will go back to a safe foundation. We assume that the media element
-        // is always safe to use after an error.
-        await this.onUnload_(has, shaka.Player.createEmptyPayload_());
-
-        // There are only two nodes that come before we start loading content,
-        // attach and detach. If we have a media element, it means we were
-        // attached to the element, and we can safely return to the attach state
-        // (we assume that the video element is always re-usable). We favor
-        // returning to the attach node since it means that the app won't need
-        // to re-attach if it saw an error.
-        return has.mediaElement ? this.attachNode_ : this.detachNode_;
-      },
-      onIdle: (node) => {
-        this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.util.FakeEvent.EventName.OnStateIdle,
-            /* data= */ (new Map()).set('state', node.name)));
-      },
-    };
-
-    /** @private {shaka.routing.Walker} */
-    this.walker_ = new shaka.routing.Walker(
-        this.detachNode_,
-        shaka.Player.createEmptyPayload_(),
-        walkerImplementation);
-
     /** @private {shaka.util.Timer} */
     this.checkVariantsTimer_ =
         new shaka.util.Timer(() => this.checkVariants_());
@@ -758,50 +726,53 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // the LAST thing we do in the constructor because conceptually it relies on
     // player having been initialized.
     if (mediaElement) {
+      shaka.Deprecate.deprecateFeature(5,
+          'Player',
+          'Please migrate from initializing Player with a mediaElement; ' +
+          'use the attach method instead.');
       this.attach(mediaElement, /* initializeMediaSource= */ true);
     }
   }
 
   /**
-   * Create a shaka.lcevc.Dil object
+   * Create a shaka.lcevc.Dec object
    * @param {shaka.extern.LcevcConfiguration} config
    * @private
    */
-  createLcevcDil_(config) {
-    if (this.lcevcDil_ == null) {
-      this.lcevcDil_ = new shaka.lcevc.Dil(
+  createLcevcDec_(config) {
+    if (this.lcevcDec_ == null) {
+      this.lcevcDec_ = new shaka.lcevc.Dec(
           /** @type {HTMLVideoElement} */ (this.video_),
           this.lcevcCanvas_,
           config,
       );
       if (this.mediaSourceEngine_) {
-        this.mediaSourceEngine_.updateLcevcDil(this.lcevcDil_);
+        this.mediaSourceEngine_.updateLcevcDec(this.lcevcDec_);
       }
     }
   }
 
   /**
-   * Close a shaka.lcevc.Dil object if present and hide the canvas.
+   * Close a shaka.lcevc.Dec object if present and hide the canvas.
    * @private
    */
-  closeLcevcDil_() {
-    if (this.lcevcDil_ != null) {
-      this.lcevcDil_.release();
-      this.lcevcDil_ = null;
+  closeLcevcDec_() {
+    if (this.lcevcDec_ != null) {
+      this.lcevcDec_.hideCanvas();
+      this.lcevcDec_.release();
+      this.lcevcDec_ = null;
     }
   }
 
   /**
-   * Setup shaka.lcevc.Dil object
+   * Setup shaka.lcevc.Dec object
    * @param {?shaka.extern.PlayerConfiguration} config
    * @private
    */
   setupLcevc_(config) {
     if (config.lcevc.enabled) {
       const tracks = this.getVariantTracks();
-      if (tracks && tracks[0] &&
-        tracks[0].videoMimeType ==
-        shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_['ts']) {
+      if (tracks && tracks[0] && tracks[0].videoMimeType == 'video/mp2t') {
         const edge = shaka.util.Platform.isEdge() ||
           shaka.util.Platform.isLegacyEdge();
         if (edge) {
@@ -815,10 +786,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           }
         }
       }
-      this.closeLcevcDil_();
-      this.createLcevcDil_(config.lcevc);
+      this.closeLcevcDec_();
+      this.createLcevcDec_(config.lcevc);
     } else {
-      this.closeLcevcDil_();
+      this.closeLcevcDec_();
     }
   }
 
@@ -844,51 +815,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    // If LCEVC Dil exists close it.
-    this.closeLcevcDil_();
+    // If LCEVC Decoder exists close it.
+    this.closeLcevcDec_();
+
+    const detachPromise = this.detach();
 
     // Mark as "dead". This should stop external-facing calls from changing our
     // internal state any more. This will stop calls to |attach|, |detach|, etc.
     // from interrupting our final move to the detached state.
     this.loadMode_ = shaka.Player.LoadMode.DESTROYED;
 
-    // Because we have set |loadMode_| to |DESTROYED| we can't call |detach|. We
-    // must talk to |this.walker_| directly.
-    const events = this.walker_.startNewRoute((currentPayload) => {
-      return {
-        node: this.detachNode_,
-        payload: shaka.Player.createEmptyPayload_(),
-        interruptible: false,
-      };
-    });
-
-    // Wait until the detach has finished so that we don't interrupt it by
-    // calling |destroy| on |this.walker_|. To avoid failing here, we always
-    // resolve the promise.
-    await new Promise((resolve) => {
-      events.onStart = () => {
-        shaka.log.info('Preparing to destroy walker...');
-      };
-      events.onEnd = () => {
-        resolve();
-      };
-      events.onCancel = () => {
-        goog.asserts.assert(false,
-            'Our final detach call should never be cancelled.');
-        resolve();
-      };
-      events.onError = () => {
-        goog.asserts.assert(false,
-            'Our final detach call should never see an error');
-        resolve();
-      };
-      events.onSkip = () => {
-        goog.asserts.assert(false,
-            'Our final detach call should never be skipped');
-        resolve();
-      };
-    });
-    await this.walker_.destroy();
+    await detachPromise;
 
     // Tear-down the event managers to ensure handlers stop firing.
     if (this.globalEventManager_) {
@@ -974,10 +911,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return false;
     }
 
-    // We do not support iOS 9, 10, 11 or 12, nor those same versions of
-    // desktop Safari.
     const safariVersion = shaka.util.Platform.safariVersion();
-    if (safariVersion && safariVersion < 13) {
+    if (safariVersion && safariVersion < 9) {
       return false;
     }
 
@@ -1036,56 +971,60 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Tell the player to use <code>mediaElement</code> for all <code>load</code>
-   * requests until <code>detach</code> or <code>destroy</code> are called.
-   *
-   * <p>
-   * Calling <code>attach</code> with <code>initializedMediaSource=true</code>
-   * will tell the player to take the initial load step and initialize media
-   * source.
-   *
-   * <p>
-   * Calls to <code>attach</code> will interrupt any in-progress calls to
-   * <code>load</code> but cannot interrupt calls to <code>attach</code>,
-   * <code>detach</code>, or <code>unload</code>.
+   * Makes a fires an event corresponding to entering a state of the loading
+   * process.
+   * @param {string} nodeName
+   * @private
+   */
+  makeStateChangeEvent_(nodeName) {
+    this.dispatchEvent(this.makeEvent_(
+        /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
+        /* data= */ (new Map()).set('state', nodeName)));
+  }
+
+  /**
+   * Attaches the player to a media element.
+   * If the player was already attached to a media element, first detaches from
+   * that media element.
    *
    * @param {!HTMLMediaElement} mediaElement
    * @param {boolean=} initializeMediaSource
    * @return {!Promise}
    * @export
    */
-  attach(mediaElement, initializeMediaSource = true) {
+  async attach(mediaElement, initializeMediaSource = true) {
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
-      return Promise.reject(this.createAbortLoadError_());
+      throw this.createAbortLoadError_();
     }
 
-    const payload = shaka.Player.createEmptyPayload_();
-    payload.mediaElement = mediaElement;
-
-    // If the platform does not support media source, we will never want to
-    // initialize media source.
-    if (!shaka.util.Platform.supportsMediaSource()) {
-      initializeMediaSource = false;
+    if (this.video_ && this.video_ != mediaElement) {
+      await this.detach();
     }
 
-    const destination = initializeMediaSource ?
-                        this.mediaSourceNode_ :
-                        this.attachNode_;
+    if (await this.atomicOperationAcquireMutex_('attach')) {
+      return;
+    }
 
-    // Do not allow this route to be interrupted because calls after this attach
-    // call will depend on the media element being attached.
-    const events = this.walker_.startNewRoute((currentPayload) => {
-      return {
-        node: destination,
-        payload: payload,
-        interruptible: false,
-      };
-    });
+    try {
+      this.makeStateChangeEvent_('attach');
 
-    // List to the events that can occur with our request.
-    events.onStart = () => shaka.log.info('Starting attach...');
-    return this.wrapWalkerListenersWithPromise_(events);
+      const onError = (error) => this.onVideoError_(error);
+      this.attachEventManager_.listen(mediaElement, 'error', onError);
+      this.video_ = mediaElement;
+
+      // Only initialize media source if the platform supports it.
+      if (initializeMediaSource &&
+          shaka.util.Platform.supportsMediaSource() &&
+          !this.mediaSourceEngine_) {
+        await this.initializeMediaSourceEngineInner_();
+      }
+    } catch (error) {
+      await this.detach();
+      throw error;
+    } finally {
+      this.mutex_.release();
+    }
   }
 
 
@@ -1101,129 +1040,246 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Tell the player to stop using its current media element. If the player is:
-   * <ul>
-   *  <li>detached, this will do nothing,
-   *  <li>attached, this will release the media element,
-   *  <li>loading, this will abort loading, unload, and release the media
-   *      element,
-   *  <li>playing content, this will stop playback, unload, and release the
-   *      media element.
-   * </ul>
+   * Detach the player from the current media element. Leaves the player in a
+   * state where it cannot play media, until it has been attached to something
+   * else.
    *
-   * <p>
-   * Calls to <code>detach</code> will interrupt any in-progress calls to
-   * <code>load</code> but cannot interrupt calls to <code>attach</code>,
-   * <code>detach</code>, or <code>unload</code>.
+   * @param {boolean=} keepAdManager
    *
    * @return {!Promise}
    * @export
    */
-  detach() {
+  async detach(keepAdManager = false) {
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
-      return Promise.reject(this.createAbortLoadError_());
+      throw this.createAbortLoadError_();
     }
 
-    // Tell the walker to go "detached", but do not allow it to be interrupted.
-    // If it could be interrupted it means that our media element could fall out
-    // of sync.
-    const events = this.walker_.startNewRoute((currentPayload) => {
-      return {
-        node: this.detachNode_,
-        payload: shaka.Player.createEmptyPayload_(),
-        interruptible: false,
-      };
-    });
+    await this.unload(/* initializeMediaSource= */ false, keepAdManager);
+
+    if (await this.atomicOperationAcquireMutex_('detach')) {
+      return;
+    }
 
-    events.onStart = () => shaka.log.info('Starting detach...');
-    return this.wrapWalkerListenersWithPromise_(events);
+    try {
+      // If we were going from "detached" to "detached" we wouldn't have
+      // a media element to detach from.
+      if (this.video_) {
+        this.attachEventManager_.removeAll();
+        this.video_ = null;
+      }
+
+      this.makeStateChangeEvent_('detach');
+
+      if (this.adManager_ && !keepAdManager) {
+        // The ad manager is specific to the video, so detach it too.
+        this.adManager_.release();
+      }
+    } finally {
+      this.mutex_.release();
+    }
   }
 
   /**
-   * Tell the player to either return to:
-   * <ul>
-   *   <li>detached (when it does not have a media element),
-   *   <li>attached (when it has a media element and
-   *     <code>initializedMediaSource=false</code>)
-   *   <li>media source initialized (when it has a media element and
-   *     <code>initializedMediaSource=true</code>)
-   * </ul>
-   *
-   * <p>
-   * Calls to <code>unload</code> will interrupt any in-progress calls to
-   * <code>load</code> but cannot interrupt calls to <code>attach</code>,
-   * <code>detach</code>, or <code>unload</code>.
+   * Tries to acquire the mutex, and then returns if the operation should end
+   * early due to someone else starting a mutex-acquiring operation.
+   * Meant for operations that can't be interrupted midway through (e.g.
+   * everything but load).
+   * @param {string} mutexIdentifier
+   * @return {!Promise.<boolean>} endEarly If false, the calling context will
+   *   need to release the mutex.
+   * @private
+   */
+  async atomicOperationAcquireMutex_(mutexIdentifier) {
+    const operationId = ++this.operationId_;
+    await this.mutex_.acquire(mutexIdentifier);
+    if (operationId != this.operationId_) {
+      this.mutex_.release();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Unloads the currently playing stream, if any.
    *
    * @param {boolean=} initializeMediaSource
+   * @param {boolean=} keepAdManager
    * @return {!Promise}
    * @export
    */
-  unload(initializeMediaSource = true) {
-    // Do not allow the player to be used after |destroy| is called.
-    if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
-      return Promise.reject(this.createAbortLoadError_());
+  async unload(initializeMediaSource = true, keepAdManager = false) {
+    // Set the load mode to unload right away so that all the public methods
+    // will stop using the internal components. We need to make sure that we
+    // are not overriding the destroyed state because we will unload when we are
+    // destroying the player.
+    if (this.loadMode_ != shaka.Player.LoadMode.DESTROYED) {
+      this.loadMode_ = shaka.Player.LoadMode.NOT_LOADED;
     }
 
-    this.fullyLoaded_ = false;
-
-    // If the platform does not support media source, we will never want to
-    // initialize media source.
-    if (!shaka.util.Platform.supportsMediaSource()) {
-      initializeMediaSource = false;
+    if (await this.atomicOperationAcquireMutex_('unload')) {
+      return;
     }
 
-    // If LCEVC Dil exists close it.
-    this.closeLcevcDil_();
+    try {
+      this.fullyLoaded_ = false;
+      this.makeStateChangeEvent_('unload');
 
-    // Since we are going either to attached or detached (through unloaded), we
-    // can't allow it to be interrupted or else we could lose track of what
-    // media element we are suppose to use.
-    //
-    // Using the current payload, we can determine which node we want to go to.
-    // If we have a media element, we want to go back to attached. If we have no
-    // media element, we want to go back to detached.
-    const payload = shaka.Player.createEmptyPayload_();
-
-    const events = this.walker_.startNewRoute((currentPayload) => {
-      // When someone calls |unload| we can either be before attached or
-      // detached (there is nothing stopping someone from calling |detach| when
-      // we are already detached).
-      //
-      // If we are attached to the correct element, we can tear down the
-      // previous playback components and go to the attached media source node
-      // depending on whether or not the caller wants to pre-init media source.
+      // If the platform does not support media source, we will never want to
+      // initialize media source.
+      if (initializeMediaSource && !shaka.util.Platform.supportsMediaSource()) {
+        initializeMediaSource = false;
+      }
+
+      // If LCEVC Decoder exists close it.
+      this.closeLcevcDec_();
+
+      // Run any general cleanup tasks now.  This should be here at the top,
+      // right after setting loadMode_, so that internal components still exist
+      // as they did when the cleanup tasks were registered in the array.
+      const cleanupTasks = this.cleanupOnUnload_.map((cb) => cb());
+      this.cleanupOnUnload_ = [];
+      await Promise.all(cleanupTasks);
+
+      // Dispatch the unloading event.
+      this.dispatchEvent(
+          this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
+
+      // Release the region timeline, which is created when parsing the
+      // manifest.
+      if (this.regionTimeline_) {
+        this.regionTimeline_.release();
+        this.regionTimeline_ = null;
+      }
+
+      // In most cases we should have a media element. The one exception would
+      // be if there was an error and we, by chance, did not have a media
+      // element.
+      if (this.video_) {
+        this.loadEventManager_.removeAll();
+      }
+
+      // Stop the variant checker timer
+      this.checkVariantsTimer_.stop();
+
+      // Some observers use some playback components, shutting down the
+      // observers first ensures that they don't try to use the playback
+      // components mid-destroy.
+      if (this.playheadObservers_) {
+        this.playheadObservers_.release();
+        this.playheadObservers_ = null;
+      }
+
+      // Stop the parser early. Since it is at the start of the pipeline, it
+      // should be start early to avoid is pushing new data downstream.
+      if (this.parser_) {
+        await this.parser_.stop();
+        this.parser_ = null;
+        this.parserFactory_ = null;
+      }
+
+      // Abr Manager will tell streaming engine what to do, so we need to stop
+      // it before we destroy streaming engine. Unlike with the other
+      // components, we do not release the instance, we will reuse it in later
+      // loads.
+      if (this.abrManager_) {
+        await this.abrManager_.stop();
+      }
+
+      // Streaming engine will push new data to media source engine, so we need
+      // to shut it down before destroy media source engine.
+      if (this.streamingEngine_) {
+        await this.streamingEngine_.destroy();
+        this.streamingEngine_ = null;
+      }
+
+      if (this.playRateController_) {
+        this.playRateController_.release();
+        this.playRateController_ = null;
+      }
+
+      // Playhead is used by StreamingEngine, so we can't destroy this until
+      // after StreamingEngine has stopped.
+      if (this.playhead_) {
+        this.playhead_.release();
+        this.playhead_ = null;
+      }
+
+      // Media source engine holds onto the media element, and in order to
+      // detach the media keys (with drm engine), we need to break the
+      // connection between media source engine and the media element.
+      if (this.mediaSourceEngine_) {
+        await this.mediaSourceEngine_.destroy();
+        this.mediaSourceEngine_ = null;
+      }
+
+      if (this.adManager_ && !keepAdManager) {
+        this.adManager_.onAssetUnload();
+      }
+
+      if (this.video_) {
+        // Remove all track nodes
+        shaka.util.Dom.removeAllChildren(this.video_);
+      }
+
+      // In order to unload a media element, we need to remove the src attribute
+      // and then load again. When we destroy media source engine, this will be
+      // done for us, but for src=, we need to do it here.
       //
-      // If we don't have a media element, we assume that we are already at the
-      // detached node - but only the walker knows that. To ensure we are
-      // actually there, we tell the walker to go to detach. While this is
-      // technically unnecessary, it ensures that we are in the state we want
-      // to be in and ready for the next request.
-      let destination = null;
-
-      if (currentPayload.mediaElement && initializeMediaSource) {
-        destination = this.mediaSourceNode_;
-      } else if (currentPayload.mediaElement) {
-        destination = this.attachNode_;
-      } else {
-        destination = this.detachNode_;
+      // DrmEngine requires this to be done before we destroy DrmEngine itself.
+      if (this.video_ && this.video_.src) {
+        // TODO: Investigate this more.  Only reproduces on Firefox 69.
+        // Introduce a delay before detaching the video source.  We are seeing
+        // spurious Promise rejections involving an AbortError in our tests
+        // otherwise.
+        await new Promise(
+            (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
+
+        this.video_.removeAttribute('src');
+        this.video_.load();
       }
 
-      goog.asserts.assert(destination, 'We should have picked a destination.');
+      if (this.drmEngine_) {
+        await this.drmEngine_.destroy();
+        this.drmEngine_ = null;
+      }
 
-      // Copy over the media element because we want to keep using the same
-      // element - the other values don't matter.
-      payload.mediaElement = currentPayload.mediaElement;
+      this.assetUri_ = null;
+      this.bufferObserver_ = null;
 
-      return {
-        node: destination,
-        payload: payload,
-        interruptible: false,
-      };
-    });
+      if (this.manifest_) {
+        for (const variant of this.manifest_.variants) {
+          for (const stream of [variant.audio, variant.video]) {
+            if (stream && stream.segmentIndex) {
+              stream.segmentIndex.release();
+            }
+          }
+        }
+        for (const stream of this.manifest_.textStreams) {
+          if (stream.segmentIndex) {
+            stream.segmentIndex.release();
+          }
+        }
+      }
+
+      this.manifest_ = null;
+      this.stats_ = new shaka.util.Stats(); // Replace with a clean object.
+      this.lastTextFactory_ = null;
+
+      this.externalSrcEqualsThumbnailsStreams_ = [];
 
-    events.onStart = () => shaka.log.info('Starting unload...');
-    return this.wrapWalkerListenersWithPromise_(events);
+      this.completionPercent_ = NaN;
+
+      // Make sure that the app knows of the new buffering state.
+      this.updateBufferState_();
+    } finally {
+      this.mutex_.release();
+    }
+
+    if (initializeMediaSource && shaka.util.Platform.supportsMediaSource() &&
+        !this.mediaSourceEngine_) {
+      await this.initializeMediaSourceEngineInner_();
+    }
   }
 
   /**
@@ -1236,120 +1292,164 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   updateStartTime(startTime) {
-    this.updatedStartTime_ = startTime;
+    this.startTime_ = startTime;
   }
 
   /**
-   * Tell the player to load the content at <code>assetUri</code> and start
-   * playback at <code>startTime</code>. Before calling <code>load</code>,
-   * a call to <code>attach</code> must have succeeded.
-   *
-   * <p>
-   * Calls to <code>load</code> will interrupt any in-progress calls to
-   * <code>load</code> but cannot interrupt calls to <code>attach</code>,
-   * <code>detach</code>, or <code>unload</code>.
+   * Loads a new stream.
+   * If another stream was already playing, first unloads that stream.
    *
    * @param {string} assetUri
    * @param {?number=} startTime
    *    When <code>startTime</code> is <code>null</code> or
    *    <code>undefined</code>, playback will start at the default start time (0
    *    for VOD and liveEdge for LIVE).
-   * @param {string=} mimeType
+   * @param {?string=} mimeType
    * @return {!Promise}
    * @export
    */
-  load(assetUri, startTime, mimeType) {
-    this.updatedStartTime_ = null;
-
-    this.fullyLoaded_ = false;
-
+  async load(assetUri, startTime = null, mimeType) {
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
-      return Promise.reject(this.createAbortLoadError_());
+      throw this.createAbortLoadError_();
     }
 
-    // We dispatch the loading event when someone calls |load| because we want
-    // to surface the user intent.
-    this.dispatchEvent(this.makeEvent_(shaka.util.FakeEvent.EventName.Loading));
+    // Quickly acquire the mutex, so this will wait for other top-level
+    // operations.
+    await this.mutex_.acquire('load');
+    this.mutex_.release();
 
-    // Right away we know what the asset uri and start-of-load time are. We will
-    // fill-in the rest of the information later.
-    const payload = shaka.Player.createEmptyPayload_();
-    payload.uri = assetUri;
-    payload.startTimeOfLoad = Date.now() / 1000;
-    if (mimeType) {
-      payload.mimeType = mimeType;
+    if (!this.video_) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.PLAYER,
+          shaka.util.Error.Code.NO_VIDEO_ELEMENT);
     }
 
-    // Because we allow |startTime| to be optional, it means that it will be
-    // |undefined| when not provided. This means that we need to re-map
-    // |undefined| to |null| while preserving |0| as a meaningful value.
-    if (startTime !== undefined) {
-      payload.startTime = startTime;
+    if (this.assetUri_) {
+      await this.unload(/* initializeMediaSource= */ false);
     }
 
-    // TODO: Refactor to determine whether it's a manifest or not, and whether
-    // or not we can play it.  Then we could return a better error than
-    // UNABLE_TO_GUESS_MANIFEST_TYPE for WebM in Safari.
-    const useSrcEquals = this.shouldUseSrcEquals_(payload);
-    const destination = useSrcEquals ? this.srcEqualsNode_ : this.loadNode_;
+    // Add a mechanism to detect if the load process has been interrupted by a
+    // call to another top-level operation (unload, load, etc).
+    const operationId = ++this.operationId_;
+    const detectInterruption = () => {
+      if (this.operationId_ != operationId) {
+        throw this.createAbortLoadError_();
+      }
+    };
 
-    // Allow this request to be interrupted, this will allow other requests to
-    // cancel a load and quickly start a new load.
-    const events = this.walker_.startNewRoute((currentPayload) => {
-      if (currentPayload.mediaElement == null) {
-        // Because we return null, this "new route" will not be used.
-        return null;
+    /**
+     * Wraps a given operation with mutex.acquire and mutex.release, along with
+     * calls to detectInterruption, to catch any other top-level calls happening
+     * while waiting for the mutex.
+     * @param {function():!Promise} operation
+     * @param {string} mutexIdentifier
+     * @return {!Promise}
+     */
+    const mutexWrapOperation = async (operation, mutexIdentifier) => {
+      try {
+        await this.mutex_.acquire(mutexIdentifier);
+        detectInterruption();
+        await operation();
+        detectInterruption();
+      } finally {
+        this.mutex_.release();
       }
+    };
 
-      // Keep using whatever media element we have right now.
-      payload.mediaElement = currentPayload.mediaElement;
+    try {
+      this.startTime_ = startTime;
+      this.fullyLoaded_ = false;
 
-      return {
-        node: destination,
-        payload: payload,
-        interruptible: true,
-      };
-    });
+      // We dispatch the loading event when someone calls |load| because we want
+      // to surface the user intent.
+      this.dispatchEvent(this.makeEvent_(
+          shaka.util.FakeEvent.EventName.Loading));
 
-    // Stats are for a single playback/load session. Stats must be initialized
-    // before we allow calls to |updateStateHistory|.
-    this.stats_ = new shaka.util.Stats();
-
-    // Load's request is a little different, so we can't use our normal
-    // listeners-to-promise method. It is the only request where we may skip the
-    // request, so we need to set the on skip callback to reject with a specific
-    // error.
-    events.onStart =
-        () => shaka.log.info('Starting load of ' + assetUri + '...');
-    return new Promise((resolve, reject) => {
-      events.onSkip = () => reject(new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.PLAYER,
-          shaka.util.Error.Code.NO_VIDEO_ELEMENT));
+      const startTimeOfLoad = Date.now() / 1000;
 
-      events.onEnd = () => {
-        resolve();
-        // We dispatch the loaded event when the load promise is resolved
-        this.dispatchEvent(
-            this.makeEvent_(shaka.util.FakeEvent.EventName.Loaded));
-      };
-      events.onCancel = () => reject(this.createAbortLoadError_());
-      events.onError = (e) => reject(e);
-    });
+      // Stats are for a single playback/load session. Stats must be initialized
+      // before we allow calls to |updateStateHistory|.
+      this.stats_ = new shaka.util.Stats();
+
+      this.assetUri_ = assetUri;
+
+      if (!mimeType) {
+        await mutexWrapOperation(async () => {
+          mimeType = await this.guessMimeType_();
+        }, 'guessMimeType_');
+      }
+      const shouldUseSrcEquals = this.shouldUseSrcEquals_(assetUri, mimeType);
+      if (shouldUseSrcEquals) {
+        await mutexWrapOperation(async () => {
+          goog.asserts.assert(mimeType, 'We should know the mimeType by now!');
+          await this.initializeSrcEqualsDrmInner_(mimeType);
+        }, 'initializeSrcEqualsDrmInner_');
+        await mutexWrapOperation(async () => {
+          goog.asserts.assert(mimeType, 'We should know the mimeType by now!');
+          await this.srcEqualsInner_(startTimeOfLoad, mimeType);
+        }, 'srcEqualsInner_');
+      } else {
+        if (!this.mediaSourceEngine_) {
+          await mutexWrapOperation(async () => {
+            await this.initializeMediaSourceEngineInner_();
+          }, 'initializeMediaSourceEngineInner_');
+        }
+        await mutexWrapOperation(async () => {
+          await this.parseManifestInner_(mimeType);
+        }, 'parseManifestInner_');
+        await mutexWrapOperation(async () => {
+          await this.initializeDrmInner_();
+        }, 'initializeDrmInner_');
+        await mutexWrapOperation(async () => {
+          await this.loadInner_(startTimeOfLoad);
+        }, 'loadInner_');
+      }
+      this.dispatchEvent(this.makeEvent_(
+          shaka.util.FakeEvent.EventName.Loaded));
+    } catch (error) {
+      if (error.code != shaka.util.Error.Code.LOAD_INTERRUPTED) {
+        await this.unload(/* initializeMediaSource= */ false);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Determines the mimeType of the given asset, if we are not told that inside
+   * the loading process.
+   *
+   * @return {!Promise.<?string>} mimeType
+   * @private
+   */
+  async guessMimeType_() {
+    goog.asserts.assert(this.assetUri_, 'should have a uri by now.');
+
+    // If no MIME type is provided, and we can't base it on extension, make a
+    // HEAD request to determine it.
+    goog.asserts.assert(this.networkingEngine_, 'Should have a net engine!');
+    const retryParams = this.config_.manifest.retryParameters;
+    let mimeType = await shaka.net.NetworkingUtils.getMimeType(
+        this.assetUri_, this.networkingEngine_, retryParams);
+    if (mimeType == 'application/x-mpegurl' && shaka.util.Platform.isApple()) {
+      mimeType = 'application/vnd.apple.mpegurl';
+    }
+    return mimeType;
   }
 
   /**
-   * Check if src= should be used to load the asset at |uri|. Assume that media
-   * source is the default option, and that src= is for special cases.
+   * Determines if we should use src equals, based on the the mimeType (if
+   * known), the URI, and platform information.
    *
-   * @param {shaka.routing.Payload} payload
+   * @param {string} assetUri
+   * @param {?string=} mimeType
    * @return {boolean}
    *    |true| if the content should be loaded with src=, |false| if the content
    *    should be loaded with MediaSource.
    * @private
    */
-  shouldUseSrcEquals_(payload) {
+  shouldUseSrcEquals_(assetUri, mimeType) {
     const Platform = shaka.util.Platform;
     const MimeUtils = shaka.util.MimeUtils;
 
@@ -1359,29 +1459,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return true;
     }
 
-    // The most accurate way to tell the player how to load the content is via
-    // MIME type.  We can fall back to features of the URI if needed.
-    let mimeType = payload.mimeType;
-    const uri = payload.uri || '';
-
-    // If we don't have a MIME type, try to guess based on the file extension.
-    // TODO: Too generic to belong to ManifestParser now.  Refactor.
-    if (!mimeType) {
-      // Try using the uri extension.
-      const extension = shaka.media.ManifestParser.getExtension(uri);
-      mimeType = shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
-    }
-
-    // TODO: The load graph system has a design limitation that requires routing
-    // destination to be chosen synchronously.  This means we can only make the
-    // right choice about src= consistently if we have a well-known file
-    // extension or API-provided MIME type.  Detection of MIME type from a HEAD
-    // request (as is done for manifest types) can't be done yet.
-
     if (mimeType) {
       // If we have a MIME type, check if the browser can play it natively.
       // This will cover both single files and native HLS.
-      const mediaElement = payload.mediaElement || Platform.anyMediaElement();
+      const mediaElement = this.video_ || Platform.anyMediaElement();
       const canPlayNatively = mediaElement.canPlayType(mimeType) != '';
 
       // If we can't play natively, then src= isn't an option.
@@ -1390,7 +1471,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
 
       const canPlayMediaSource =
-          shaka.media.ManifestParser.isSupported(uri, mimeType);
+          shaka.media.ManifestParser.isSupported(mimeType);
 
       // If MediaSource isn't an option, the native option is our only chance.
       if (!canPlayMediaSource) {
@@ -1404,17 +1485,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // We would prefer MediaSource in some cases, and src= in others.  For
       // example, Android has native HLS, but we'd prefer our own MediaSource
       // version there.
+      if (MimeUtils.isHlsType(mimeType)) {
+        // Native HLS can be preferred on any platform via this flag:
+        if (this.config_.streaming.preferNativeHls) {
+          return true;
+        }
 
-      // Native HLS can be preferred on any platform via this flag:
-      if (MimeUtils.isHlsType(mimeType) &&
-          this.config_.streaming.preferNativeHls) {
-        return true;
-      }
-
-      // For Safari, we have an older flag which only applies to this one
-      // browser:
-      if (Platform.isApple()) {
-        return this.config_.streaming.useNativeHlsOnSafari;
+        // For Safari, we have an older flag which only applies to this one
+        // browser:
+        if (Platform.isApple()) {
+          return this.config_.streaming.useNativeHlsOnSafari;
+        }
       }
 
       // In all other cases, we prefer MediaSource.
@@ -1428,298 +1509,40 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * This should only be called by the load graph when it is time to attach to
-   * a media element. The only times this may be called are when we are being
-   * asked to re-attach to the current media element, or attach to a new media
-   * element while not attached to a media element.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
+   * Initializes the media source engine.
    *
-   * Attaching to a media element is defined as:
-   *  - Registering error listeners to the media element.
-   *  - Caching the video element for use outside of the load graph.
-   *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
    * @return {!Promise}
    * @private
    */
-  onAttach_(has, wants) {
-    // If we don't have a media element yet, it means we are entering
-    // "attach" from another node.
-    //
-    // If we have a media element, it should match |wants.mediaElement|
-    // because it means we are going from "attach" to "attach".
-    //
-    // These constraints should be maintained and guaranteed by the routing
-    // logic in |getNextStep_|.
-    goog.asserts.assert(
-        has.mediaElement == null || has.mediaElement == wants.mediaElement,
-        'The routing logic failed. MediaElement requirement failed.');
-
-    if (has.mediaElement == null) {
-      has.mediaElement = wants.mediaElement;
-
-      const onError = (error) => this.onVideoError_(error);
-      this.attachEventManager_.listen(has.mediaElement, 'error', onError);
-    }
-
-    this.video_ = has.mediaElement;
-
-    return Promise.resolve();
-  }
-
-  /**
-   * This should only be called by the load graph when it is time to detach from
-   * a media element. The only times this may be called are when we are being
-   * asked to detach from the current media element, or detach when we are
-   * already detached.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
-   *
-   * Detaching from a media element is defined as:
-   *  - Removing error listeners from the media element.
-   *  - Dropping the cached reference to the video element.
-   *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {!Promise}
-   * @private
-   */
-  onDetach_(has, wants) {
-    // If we were going from "detached" to "detached" we wouldn't have
-    // a media element to detach from.
-    if (has.mediaElement) {
-      this.attachEventManager_.removeAll();
-      has.mediaElement = null;
-    }
-
-    if (this.adManager_) {
-      // The ad manager is specific to the video, so detach it too.
-      this.adManager_.release();
-    }
-
-    // Clear our cached copy of the media element.
-    this.video_ = null;
-
-    return Promise.resolve();
-  }
-
-  /**
-   * This should only be called by the load graph when it is time to unload all
-   * currently initialized playback components. Unlike the other load actions,
-   * this action is built to be more general. We need to do this because we
-   * don't know what state the player will be in before unloading (including
-   * after an error occurred in the middle of a transition).
-   *
-   * This method assumes that any component could be |null| and should be safe
-   * to call from any point in the load graph.
-   *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {!Promise}
-   * @private
-   */
-  async onUnload_(has, wants) {
-    // Set the load mode to unload right away so that all the public methods
-    // will stop using the internal components. We need to make sure that we
-    // are not overriding the destroyed state because we will unload when we are
-    // destroying the player.
-    if (this.loadMode_ != shaka.Player.LoadMode.DESTROYED) {
-      this.loadMode_ = shaka.Player.LoadMode.NOT_LOADED;
-    }
-
-    // Run any general cleanup tasks now.  This should be here at the top, right
-    // after setting loadMode_, so that internal components still exist as they
-    // did when the cleanup tasks were registered in the array.
-    const cleanupTasks = this.cleanupOnUnload_.map((cb) => cb());
-    this.cleanupOnUnload_ = [];
-    await Promise.all(cleanupTasks);
-
-    // Dispatch the unloading event.
-    this.dispatchEvent(
-        this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
-
-    // Remove everything that has to do with loading content from our payload
-    // since we are releasing everything that depended on it.
-    has.mimeType = null;
-    has.startTime = null;
-    has.uri = null;
-
-    // Release the region timeline, which is created when parsing the manifest.
-    if (this.regionTimeline_) {
-      this.regionTimeline_.release();
-      this.regionTimeline_ = null;
-    }
-
-    // In most cases we should have a media element. The one exception would
-    // be if there was an error and we, by chance, did not have a media element.
-    if (has.mediaElement) {
-      this.loadEventManager_.removeAll();
-    }
-
-    // Stop the variant checker timer
-    this.checkVariantsTimer_.stop();
-
-    // Some observers use some playback components, shutting down the observers
-    // first ensures that they don't try to use the playback components
-    // mid-destroy.
-    if (this.playheadObservers_) {
-      this.playheadObservers_.release();
-      this.playheadObservers_ = null;
-    }
-
-    if (this.bufferPoller_) {
-      this.bufferPoller_.stop();
-      this.bufferPoller_ = null;
-    }
-
-    // Stop the parser early. Since it is at the start of the pipeline, it
-    // should be start early to avoid is pushing new data downstream.
-    if (this.parser_) {
-      await this.parser_.stop();
-      this.parser_ = null;
-      this.parserFactory_ = null;
-    }
-
-    // Abr Manager will tell streaming engine what to do, so we need to stop
-    // it before we destroy streaming engine. Unlike with the other components,
-    // we do not release the instance, we will reuse it in later loads.
-    if (this.abrManager_) {
-      await this.abrManager_.stop();
-    }
-
-    // Streaming engine will push new data to media source engine, so we need
-    // to shut it down before destroy media source engine.
-    if (this.streamingEngine_) {
-      await this.streamingEngine_.destroy();
-      this.streamingEngine_ = null;
-    }
-
-    if (this.playRateController_) {
-      this.playRateController_.release();
-      this.playRateController_ = null;
-    }
-
-    // Playhead is used by StreamingEngine, so we can't destroy this until after
-    // StreamingEngine has stopped.
-    if (this.playhead_) {
-      this.playhead_.release();
-      this.playhead_ = null;
-    }
-
-    // Media source engine holds onto the media element, and in order to detach
-    // the media keys (with drm engine), we need to break the connection between
-    // media source engine and the media element.
-    if (this.mediaSourceEngine_) {
-      await this.mediaSourceEngine_.destroy();
-      this.mediaSourceEngine_ = null;
-    }
-
-    if (this.adManager_) {
-      this.adManager_.onAssetUnload();
-    }
-
-    // In order to unload a media element, we need to remove the src attribute
-    // and then load again. When we destroy media source engine, this will be
-    // done for us, but for src=, we need to do it here.
-    //
-    // DrmEngine requires this to be done before we destroy DrmEngine itself.
-    if (has.mediaElement && has.mediaElement.src) {
-      // TODO: Investigate this more.  Only reproduces on Firefox 69.
-      // Introduce a delay before detaching the video source.  We are seeing
-      // spurious Promise rejections involving an AbortError in our tests
-      // otherwise.
-      await new Promise(
-          (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
-
-      has.mediaElement.removeAttribute('src');
-      has.mediaElement.load();
-      // Remove all track nodes
-      while (has.mediaElement.lastChild) {
-        has.mediaElement.removeChild(has.mediaElement.firstChild);
-      }
-    }
-
-    if (this.drmEngine_) {
-      await this.drmEngine_.destroy();
-      this.drmEngine_ = null;
-    }
-
-    this.assetUri_ = null;
-    this.bufferObserver_ = null;
-
-    if (this.manifest_) {
-      for (const variant of this.manifest_.variants) {
-        for (const stream of [variant.audio, variant.video]) {
-          if (stream && stream.segmentIndex) {
-            stream.segmentIndex.release();
-          }
-        }
-      }
-      for (const stream of this.manifest_.textStreams) {
-        if (stream.segmentIndex) {
-          stream.segmentIndex.release();
-        }
-      }
-    }
-
-    this.manifest_ = null;
-    this.stats_ = new shaka.util.Stats(); // Replace with a clean stats object.
-    this.lastTextFactory_ = null;
-
-    // Make sure that the app knows of the new buffering state.
-    this.updateBufferState_();
-  }
-
-  /**
-   * This should only be called by the load graph when it is time to initialize
-   * media source engine. The only time this may be called is when we are
-   * attached to the same media element as in the request.
-   *
-   * This method assumes that it is safe for it to execute. The load-graph is
-   * responsible for ensuring all assumptions are true.
-   *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   *
-   * @return {!Promise}
-   * @private
-   */
-  async onInitializeMediaSourceEngine_(has, wants) {
+  async initializeMediaSourceEngineInner_() {
     goog.asserts.assert(
         shaka.util.Platform.supportsMediaSource(),
-        'We should not be initializing media source on a platform that does ' +
-            'not support media source.');
+        'We should not be initializing media source on a platform that ' +
+            'does not support media source.');
     goog.asserts.assert(
-        has.mediaElement,
+        this.video_,
         'We should have a media element when initializing media source.');
-    goog.asserts.assert(
-        has.mediaElement == wants.mediaElement,
-        '|has| and |wants| should have the same media element when ' +
-            'initializing media source.');
-
     goog.asserts.assert(
         this.mediaSourceEngine_ == null,
         'We should not have a media source engine yet.');
 
+    this.makeStateChangeEvent_('media-source');
+
     // When changing text visibility we need to update both the text displayer
-    // and streaming engine because we don't always stream text. To ensure that
-    // text displayer and streaming engine are always in sync, wait until they
-    // are both initialized before setting the initial value.
+    // and streaming engine because we don't always stream text. To ensure
+    // that the text displayer and streaming engine are always in sync, wait
+    // until they are both initialized before setting the initial value.
     const textDisplayerFactory = this.config_.textDisplayFactory;
     const textDisplayer = textDisplayerFactory();
     this.lastTextFactory_ = textDisplayerFactory;
 
     const mediaSourceEngine = this.createMediaSourceEngine(
-        has.mediaElement,
+        this.video_,
         textDisplayer,
         (metadata, offset, endTime) => {
           this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
         },
-        this.lcevcDil_);
+        this.lcevcDec_);
     mediaSourceEngine.configure(this.config_.mediaSource);
     const {segmentRelativeVttTiming} = this.config_.manifest;
     mediaSourceEngine.setSegmentRelativeVttTiming(segmentRelativeVttTiming);
@@ -1733,114 +1556,51 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Create the parser for the asset located at |wants.uri|. This should only be
-   * called as part of the load graph.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
+   * Pick an initialize a manifest parser, then have it download and parse the
+   * manifest.
    *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
+   * @param {?string=} mimeType
    * @return {!Promise}
    * @private
    */
-  async onInitializeParser_(has, wants) {
+  async parseManifestInner_(mimeType) {
     goog.asserts.assert(
-        has.mediaElement,
-        'We should have a media element when initializing the parser.');
+        this.assetUri_,
+        'should have a uri when making the parser.');
     goog.asserts.assert(
-        has.mediaElement == wants.mediaElement,
-        '|has| and |wants| should have the same media element when ' +
-            'initializing the parser.');
-
+        this.video_,
+        'We should have a media element when initializing the parser.');
     goog.asserts.assert(
         this.networkingEngine_,
         'Need networking engine when initializing the parser.');
+    goog.asserts.assert(
+        this.cmcdManager_,
+        'Need CMCD manager to populate manifest request data.');
     goog.asserts.assert(
         this.config_,
         'Need player config when initializing the parser.');
 
-    // We are going to "lock-in" the mime type and uri since they are
-    // what we are going to use to create our parser and parse the manifest.
-    has.mimeType = wants.mimeType;
-    has.uri = wants.uri;
-
-    goog.asserts.assert(
-        has.uri,
-        'We should have an asset uri when initializing the parsing.');
-
-    // Store references to things we asserted so that we don't need to reassert
-    // them again later.
-    const assetUri = has.uri;
+    // Store references to things we asserted so that we don't need to
+    // reassert them again later.
     const networkingEngine = this.networkingEngine_;
 
-    // Save the uri so that it can be used outside of the load-graph.
-    this.assetUri_ = assetUri;
+    this.makeStateChangeEvent_('manifest-parser');
 
     // Create the parser that we will use to parse the manifest.
-    this.parserFactory_ = await shaka.media.ManifestParser.getFactory(
-        assetUri,
-        networkingEngine,
-        this.config_.manifest.retryParameters,
-        has.mimeType);
+    this.parserFactory_ = shaka.media.ManifestParser.getFactory(
+        this.assetUri_,
+        mimeType || null);
     goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
     this.parser_ = this.parserFactory_();
 
     const manifestConfig =
         shaka.util.ObjectUtils.cloneObject(this.config_.manifest);
     // Don't read video segments if the player is attached to an audio element
-    if (wants.mediaElement && wants.mediaElement.nodeName === 'AUDIO') {
+    if (this.video_ && this.video_.nodeName === 'AUDIO') {
       manifestConfig.disableVideo = true;
     }
 
     this.parser_.configure(manifestConfig);
-  }
-
-  /**
-   * Parse the manifest at |has.uri| using the parser that should have already
-   * been created. This should only be called as part of the load graph.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
-   *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {!shaka.util.AbortableOperation}
-   * @private
-   */
-  onParseManifest_(has, wants) {
-    goog.asserts.assert(
-        has.mimeType == wants.mimeType,
-        '|has| and |wants| should have the same mime type when parsing.');
-    goog.asserts.assert(
-        has.uri == wants.uri,
-        '|has| and |wants| should have the same uri when parsing.');
-
-    goog.asserts.assert(
-        has.uri,
-        '|has| should have a valid uri when parsing.');
-    goog.asserts.assert(
-        has.uri == this.assetUri_,
-        '|has.uri| should match the cached asset uri.');
-
-    goog.asserts.assert(
-        this.networkingEngine_,
-        'Need networking engine to parse manifest.');
-    goog.asserts.assert(
-        this.cmcdManager_,
-        'Need CMCD manager to populate manifest request data.');
-    goog.asserts.assert(
-        this.config_,
-        'Need player config to parse manifest.');
-
-    goog.asserts.assert(
-        this.parser_,
-        '|this.parser_| should have been set in an earlier step.');
-
-    // Store references to things we asserted so that we don't need to reassert
-    // them again later.
-    const assetUri = has.uri;
-    const networkingEngine = this.networkingEngine_;
 
     // This will be needed by the parser once it starts parsing, so we will
     // initialize it now even through it appears a little out-of-place.
@@ -1881,7 +1641,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // Called when the parser finds a timeline region. This can be called
       // before we start playback or during playback (live/in-progress
       // manifest).
-      onTimelineRegionAdded: (region) => this.regionTimeline_.addRegion(region),
+      onTimelineRegionAdded: (region) => {
+        this.regionTimeline_.addRegion(region);
+      },
 
       onEvent: (event) => this.dispatchEvent(event),
       onError: (error) => this.onError_(error),
@@ -1904,61 +1666,54 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.processDrmInfos_(currentDrmInfo.keySystem, stream);
         }
       },
+      onManifestUpdated: () => {
+        const eventName = shaka.util.FakeEvent.EventName.ManifestUpdated;
+        const data = (new Map()).set('isLive', this.isLive());
+        this.dispatchEvent(this.makeEvent_(eventName, data));
+        if (this.adManager_) {
+          this.adManager_.onManifestUpdated(this.isLive());
+        }
+      },
+      getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
     };
 
     const startTime = Date.now() / 1000;
 
-    return new shaka.util.AbortableOperation(/* promise= */ (async () => {
-      this.manifest_ = await this.parser_.start(assetUri, playerInterface);
+    this.makeStateChangeEvent_('manifest');
 
-      // This event is fired after the manifest is parsed, but before any
-      // filtering takes place.
-      const event =
-          this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
-      this.dispatchEvent(event);
+    this.manifest_ = await this.parser_.start(
+        this.assetUri_, playerInterface);
 
-      // We require all manifests to have at least one variant.
-      if (this.manifest_.variants.length == 0) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.NO_VARIANTS);
-      }
+    // This event is fired after the manifest is parsed, but before any
+    // filtering takes place.
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
+    this.dispatchEvent(event);
 
-      // Make sure that all variants are either: audio-only, video-only, or
-      // audio-video.
-      shaka.Player.filterForAVVariants_(this.manifest_);
+    // We require all manifests to have at least one variant.
+    if (this.manifest_.variants.length == 0) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.NO_VARIANTS);
+    }
 
-      const now = Date.now() / 1000;
-      const delta = now - startTime;
-      this.stats_.setManifestTime(delta);
-    })(), /* onAbort= */ () => {
-      shaka.log.info('Aborting parser step...');
-      return this.parser_.stop();
-    });
+    // Make sure that all variants are either: audio-only, video-only, or
+    // audio-video.
+    shaka.Player.filterForAVVariants_(this.manifest_);
+
+    const now = Date.now() / 1000;
+    const delta = now - startTime;
+    this.stats_.setManifestTime(delta);
   }
 
   /**
-   * This should only be called by the load graph when it is time to initialize
-   * drmEngine. The only time this may be called is when we are attached a
-   * media element and have parsed a manifest.
-   *
-   * The load-graph is responsible for ensuring all assumptions made by this
-   * method are valid before executing it.
+   * Initializes the DRM engine.
    *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
    * @return {!Promise}
    * @private
    */
-  async onInitializeDrm_(has, wants) {
-    goog.asserts.assert(
-        has.mimeType == wants.mimeType,
-        'The load graph should have ensured the mime types matched.');
-    goog.asserts.assert(
-        has.uri == wants.uri,
-        'The load graph should have ensured the uris matched');
-
+  async initializeDrmInner_() {
     goog.asserts.assert(
         this.networkingEngine_,
         '|onInitializeDrm_| should never be called after |destroy|');
@@ -1969,9 +1724,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_,
         '|this.manifest_| should have been set in an earlier step.');
     goog.asserts.assert(
-        has.mediaElement,
+        this.video_,
         'We should have a media element when initializing the DRM Engine.');
 
+    this.makeStateChangeEvent_('drm-engine');
+
     const startTime = Date.now() / 1000;
     let firstEvent = true;
 
@@ -1994,14 +1751,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           const now = Date.now() / 1000;
           const delta = now - startTime;
           this.stats_.setDrmTime(delta);
-          // LCEVC data by itself is not encrypted in DRM protected streams and
-          // can therefore be accessed and decoded as normal. However, the LCEVC
-          // decoder needs access to the VideoElement output in order to apply
-          // the enhancement. In DRM contexts where the browser CDM restricts
-          // access from our decoder, the enhancement cannot be applied and
-          // therefore the LCEVC output canvas is hidden accordingly.
-          if (this.lcevcDil_) {
-            this.lcevcDil_.hideCanvas();
+          // LCEVC data by itself is not encrypted in DRM protected streams
+          // and can therefore be accessed and decoded as normal. However,
+          // the LCEVC decoder needs access to the VideoElement output in
+          // order to apply the enhancement. In DRM contexts where the
+          // browser CDM restricts access from our decoder, the enhancement
+          // cannot be applied and therefore the LCEVC output canvas is
+          // hidden accordingly.
+          if (this.lcevcDec_) {
+            this.lcevcDec_.hideCanvas();
           }
         }
       },
@@ -2013,66 +1771,31 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_.variants,
         this.manifest_.offlineSessionIds);
 
-    await this.drmEngine_.attach(has.mediaElement);
+    await this.drmEngine_.attach(this.video_);
 
-    // Now that we have drm information, filter the manifest (again) so that we
-    // can ensure we only use variants with the selected key system.
+    // Now that we have drm information, filter the manifest (again) so that
+    // we can ensure we only use variants with the selected key system.
     await this.filterManifest_(this.manifest_);
   }
 
   /**
-   * This should only be called by the load graph when it is time to load all
-   * playback components needed for playback. The only times this may be called
-   * is when we are attached to the same media element as in the request.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
-   *
-   * Loading is defined as:
-   *  - Attaching all playback-related listeners to the media element
-   *  - Initializing playback and observers
-   *  - Initializing ABR Manager
-   *  - Initializing Streaming Engine
-   *  - Starting playback at |wants.startTime|
+   * Starts loading the content described by the parsed manifest.
    *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
+   * @param {number} startTimeOfLoad
+   * @return {!Promise}
    * @private
    */
-  async onLoad_(has, wants) {
+  async loadInner_(startTimeOfLoad) {
     goog.asserts.assert(
-        has.mimeType == wants.mimeType,
-        '|has| and |wants| should have the same mime type when loading.');
-    goog.asserts.assert(
-        has.uri == wants.uri,
-        '|has| and |wants| should have the same uri when loading.');
-
+        this.video_, 'We should have a media element by now.');
     goog.asserts.assert(
-        has.mediaElement,
-        'We should have a media element when loading.');
+        this.manifest_, 'The manifest should already be parsed.');
     goog.asserts.assert(
-        !isNaN(wants.startTimeOfLoad),
-        '|wants| should tell us when the load was originally requested');
+        this.assetUri_, 'We should have an asset uri by now.');
 
-    // Since we are about to start playback, we will lock in the start time as
-    // something we are now depending on.
-    has.startTime = wants.startTime;
-
-    // If updateStartTime() has been called since load() was invoked use the
-    // requested startTime
-    if (this.updatedStartTime_ != null) {
-      has.startTime = this.updatedStartTime_;
-      this.updatedStartTime_ = null;
-    }
-
-    // Store a reference to values in |has| after asserting so that closure will
-    // know that they will still be non-null between calls to await.
-    const mediaElement = has.mediaElement;
-    const assetUri = has.uri;
-
-    // Save the uri so that it can be used outside of the load-graph.
-    this.assetUri_ = assetUri;
+    this.makeStateChangeEvent_('load');
 
+    const mediaElement = this.video_;
     this.playRateController_ = new shaka.media.PlayRateController({
       getRate: () => mediaElement.playbackRate,
       getDefaultRate: () => mediaElement.defaultPlaybackRate,
@@ -2082,13 +1805,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(
+        mediaElement, 'playing', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
 
-    // Check status of the LCEVC DIL Object and reset or
-    // create or close based on config
+    // Check the status of the LCEVC Dec Object. Reset, create, or close
+    // depending on the config.
     this.setupLcevc_(this.config_);
 
     const abrFactory = this.config_.abrFactory;
@@ -2112,7 +1836,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             this.config_.preferredVariantRole,
             this.config_.preferredAudioChannelCount,
             this.config_.preferredVideoHdrLevel,
-            this.config_.preferredAudioLabel);
+            this.config_.preferredVideoLayout,
+            this.config_.preferredAudioLabel,
+            this.config_.mediaSource.codecSwitchingStrategy,
+            this.config_.manifest.dash.enableAudioGroups);
 
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
     this.currentTextRole_ = this.config_.preferredTextRole;
@@ -2133,7 +1860,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_,
         this.config_.preferredVideoCodecs,
         this.config_.preferredAudioCodecs,
-        this.config_.preferredAudioChannelCount,
         this.config_.preferredDecodingAttributes);
 
     this.streamingEngine_ = this.createStreamingEngine();
@@ -2175,7 +1901,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     let initialVariant = null;
     const activeVariant = this.streamingEngine_.getCurrentVariant();
     if (!activeVariant) {
-      initialVariant = this.chooseVariant_();
+      initialVariant = this.chooseVariant_(/* initialSelection= */ true);
       goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
     }
 
@@ -2191,20 +1917,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       await Promise.all(createSegmentIndexPromises);
     }
 
+    if (this.parser_ && this.parser_.onInitialVariantChosen) {
+      this.parser_.onInitialVariantChosen(toLazyLoad);
+    }
+
     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
 
-    this.playhead_ = this.createPlayhead(has.startTime);
+    this.playhead_ = this.createPlayhead(this.startTime_);
     this.playheadObservers_ =
-        this.createPlayheadObserversForMSE_(has.startTimeOfLoad);
+        this.createPlayheadObserversForMSE_(startTimeOfLoad);
 
-    // We need to start the buffer management code near the end because it will
-    // set the initial buffering state and that depends on other components
-    // being initialized.
+    // We need to start the buffer management code near the end because it
+    // will set the initial buffering state and that depends on other
+    // components being initialized.
     const rebufferThreshold = Math.max(
         this.manifest_.minBufferTime, this.config_.streaming.rebufferingGoal);
-    this.startBufferManagement_(rebufferThreshold);
+    this.startBufferManagement_(mediaElement, rebufferThreshold);
 
     // Now we can switch to the initial variant.
     if (!activeVariant) {
@@ -2214,14 +1944,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
           /* clearBuffer= */ false, /* safeMargin= */ 0);
 
-      // Now that we have initial streams, we may adjust the start time to align
-      // to a segment boundary.
+      // Now that we have initial streams, we may adjust the start time to
+      // align to a segment boundary.
       if (this.config_.streaming.startAtSegmentBoundary) {
-        const startTime = this.playhead_.getTime();
-        const adjustedTime =
-            await this.adjustStartTime_(initialVariant, startTime);
-
-        this.playhead_.setStartTime(adjustedTime);
+        this.playhead_.setStartTime(await this.adjustStartTime_(
+            initialVariant, this.playhead_.getTime()));
       }
     }
 
@@ -2244,7 +1971,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.setInitialTextState_(initialVariant, initialTextStream);
       }
 
-      // Don't initialize with a text stream unless we should be streaming text.
+      // Don't initialize with a text stream unless we should be streaming
+      // text.
       if (initialTextStream && this.shouldStreamText_()) {
         this.streamingEngine_.switchTextStream(initialTextStream);
       }
@@ -2260,9 +1988,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.onAbrStatusChanged_();
     }
 
-    // Re-filter the manifest after streams have been chosen.
-    this.filterManifestByCurrentVariant_();
-    // Dispatch a 'trackschanged' event now that all initial filtering is done.
+    // Dispatch a 'trackschanged' event now that all initial filtering is
+    // done.
     this.onTracksChanged_();
 
     // Now that we've filtered out variants that aren't compatible with the
@@ -2276,14 +2003,25 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const hasPrimary = this.manifest_.variants.some((v) => v.primary);
     if (!this.config_.preferredAudioLanguage && !hasPrimary) {
-      shaka.log.warning('No preferred audio language set.  We have chosen an ' +
-                        'arbitrary language initially');
+      shaka.log.warning('No preferred audio language set.  ' +
+          'We have chosen an arbitrary language initially');
     }
 
-    if (this.isLive() && (this.config_.streaming.liveSync ||
+    const isLive = this.isLive();
+
+    if (isLive && (this.config_.streaming.liveSync ||
         this.manifest_.serviceDescription)) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
+    } else if (!isLive) {
+      const onVideoProgress = () => this.onVideoProgress_();
+      this.loadEventManager_.listen(
+          mediaElement, 'timeupdate', onVideoProgress);
+      this.onVideoProgress_();
+    }
+
+    if (this.adManager_) {
+      this.adManager_.onManifestUpdated(isLive);
     }
 
     this.fullyLoaded_ = true;
@@ -2291,24 +2029,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Wait for the 'loadedmetadata' event to measure load() latency.
     this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
       const now = Date.now() / 1000;
-      const delta = now - wants.startTimeOfLoad;
+      const delta = now - startTimeOfLoad;
       this.stats_.setLoadLatency(delta);
     });
   }
 
   /**
-   * This should only be called by the load graph when it is time to initialize
-   * drmEngine for src= playbacks.
-   *
-   * The load-graph is responsible for ensuring all assumptions made by this
-   * method are valid before executing it.
+   * Initializes the DRM engine for use by src equals.
    *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
+   * @param {string} mimeType
    * @return {!Promise}
    * @private
    */
-  async onInitializeSrcEqualsDrm_(has, wants) {
+  async initializeSrcEqualsDrmInner_(mimeType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(
@@ -2346,20 +2079,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     this.drmEngine_.configure(this.config_.drm);
 
-    const uri = wants.uri || '';
-    const extension = shaka.media.ManifestParser.getExtension(uri);
-    let mimeType = shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
-    if (mimeType == 'application/x-mpegurl' && shaka.util.Platform.isApple()) {
-      mimeType = 'application/vnd.apple.mpegurl';
-    }
-    if (!mimeType) {
-      mimeType = 'video/mp4';
-    }
-
     // TODO: Instead of feeding DrmEngine with Variants, we should refactor
     // DrmEngine so that it takes a minimal config derived from Variants.  In
     // cases like this one or in removal of stored content, the details are
-    // largely unimportant.  We should have a saner way to initialize DrmEngine.
+    // largely unimportant.  We should have a saner way to initialize
+    // DrmEngine.
     // That would also insulate DrmEngine from manifest changes in the future.
     // For now, that is time-consuming and this synthetic Variant is easy, so
     // I'm putting it off.  Since this is only expected to be used for native
@@ -2374,12 +2098,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       video: {
         id: 0,
         originalId: null,
+        groupId: null,
         createSegmentIndex: () => Promise.resolve(),
         segmentIndex: null,
-        mimeType: wants.mimeType ?
-            shaka.util.MimeUtils.getBasicType(wants.mimeType) : mimeType,
-        codecs: wants.mimeType ?
-            shaka.util.MimeUtils.getCodecs(wants.mimeType) : '',
+        mimeType: mimeType ? shaka.util.MimeUtils.getBasicType(mimeType) : '',
+        codecs: mimeType ? shaka.util.MimeUtils.getCodecs(mimeType) : '',
         encrypted: true,
         drmInfos: [],  // Filled in by DrmEngine config.
         keyIds: new Set(),
@@ -2398,6 +2121,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         closedCaptions: null,
         accessibilityPurpose: null,
         external: false,
+        fastSwitching: false,
       },
       bandwidth: 100,
       allowedByApplication: true,
@@ -2408,46 +2132,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
         [variant], /* offlineSessionIds= */ []);
-    await this.drmEngine_.attach(has.mediaElement);
+    await this.drmEngine_.attach(this.video_);
   }
 
   /**
-   * This should only be called by the load graph when it is time to set-up the
-   * media element to play content using src=. The only times this may be called
-   * is when we are attached to the same media element as in the request.
-   *
-   * This method assumes that it is safe for it to execute, the load-graph is
-   * responsible for ensuring all assumptions are true.
+   * Passes the asset URI along to the media element, so it can be played src
+   * equals style.
    *
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {!shaka.util.AbortableOperation}
+   * @param {number} startTimeOfLoad
+   * @param {string} mimeType
+   * @return {!Promise}
    *
    * @private
    */
-  onSrcEquals_(has, wants) {
-    goog.asserts.assert(
-        has.mediaElement,
-        'We should have a media element when loading.');
-    goog.asserts.assert(
-        wants.uri,
-        '|has| should have a valid uri when loading.');
+  async srcEqualsInner_(startTimeOfLoad, mimeType) {
+    this.makeStateChangeEvent_('src-equals');
+
     goog.asserts.assert(
-        !isNaN(wants.startTimeOfLoad),
-        '|wants| should tell us when the load was originally requested');
+        this.video_, 'We should have a media element when loading.');
     goog.asserts.assert(
-        this.video_ == has.mediaElement,
-        'The video element should match our media element');
-
-    // Lock-in the values that we are using so that the routing logic knows what
-    // we have.
-    has.uri = wants.uri;
-    has.startTime = wants.startTime;
-
-    // Save the uri so that it can be used outside of the load-graph.
-    this.assetUri_ = has.uri;
+        this.assetUri_, 'We should have a valid uri when loading.');
 
-    const mediaElement = has.mediaElement;
+    const mediaElement = this.video_;
 
     this.playhead_ = new shaka.media.SrcEqualsPlayhead(mediaElement);
 
@@ -2458,8 +2164,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       unloaded = true;
     });
 
-    if (has.startTime != null) {
-      this.playhead_.setStartTime(has.startTime);
+    if (this.startTime_ != null) {
+      this.playhead_.setStartTime(this.startTime_);
     }
 
     this.playRateController_ = new shaka.media.PlayRateController({
@@ -2469,16 +2175,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       movePlayhead: (delta) => { mediaElement.currentTime += delta; },
     });
 
-    // We need to start the buffer management code near the end because it will
-    // set the initial buffering state and that depends on other components
-    // being initialized.
+    // We need to start the buffer management code near the end because it
+    // will set the initial buffering state and that depends on other
+    // components being initialized.
     const rebufferThreshold = this.config_.streaming.rebufferingGoal;
-    this.startBufferManagement_(rebufferThreshold);
+    this.startBufferManagement_(mediaElement, rebufferThreshold);
 
     // Add all media element listeners.
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(
+        mediaElement, 'playing', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
     this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
@@ -2488,24 +2195,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // automatically.
     // See https://github.com/shaka-project/shaka-player/issues/2483
     if (mediaElement.preload != 'none') {
-      this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
-        const now = Date.now() / 1000;
-        const delta = now - wants.startTimeOfLoad;
-        this.stats_.setLoadLatency(delta);
-      });
+      this.loadEventManager_.listenOnce(
+          mediaElement, 'loadedmetadata', () => {
+            const now = Date.now() / 1000;
+            const delta = now - startTimeOfLoad;
+            this.stats_.setLoadLatency(delta);
+          });
     }
 
     // The audio tracks are only available on Safari at the moment, but this
     // drives the tracks API for Safari's native HLS. So when they change,
     // fire the corresponding Shaka Player event.
     if (mediaElement.audioTracks) {
-      this.loadEventManager_.listen(
-          mediaElement.audioTracks, 'addtrack', () => this.onTracksChanged_());
-      this.loadEventManager_.listen(
-          mediaElement.audioTracks, 'removetrack',
+      this.loadEventManager_.listen(mediaElement.audioTracks, 'addtrack',
+          () => this.onTracksChanged_());
+      this.loadEventManager_.listen(mediaElement.audioTracks, 'removetrack',
+          () => this.onTracksChanged_());
+      this.loadEventManager_.listen(mediaElement.audioTracks, 'change',
           () => this.onTracksChanged_());
-      this.loadEventManager_.listen(
-          mediaElement.audioTracks, 'change', () => this.onTracksChanged_());
     }
 
     if (mediaElement.textTracks) {
@@ -2541,13 +2248,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           () => this.onTracksChanged_());
     }
 
-    const extension = shaka.media.ManifestParser.getExtension(has.uri);
-    const mimeType =
-      shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
-
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
+    mediaElement.src = this.cmcdManager_.appendSrcData(
+        this.assetUri_, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
@@ -2561,15 +2265,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // initialized.
     this.loadMode_ = shaka.Player.LoadMode.SRC_EQUALS;
 
-    // The event doesn't mean as much for src= playback, since we don't control
-    // streaming.  But we should fire it in this path anyway since some
-    // applications may be expecting it as a life-cycle event.
+    // The event doesn't mean as much for src= playback, since we don't
+    // control streaming.  But we should fire it in this path anyway since
+    // some applications may be expecting it as a life-cycle event.
     this.dispatchEvent(
         this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
 
     // The "load" Promise is resolved when we have loaded the metadata.  If we
-    // wait for the full data, that won't happen on Safari until the play button
-    // is hit.
+    // wait for the full data, that won't happen on Safari until the play
+    // button is hit.
     const fullyLoaded = new shaka.util.PublicPromise();
     shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_METADATA,
@@ -2579,7 +2283,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           fullyLoaded.resolve();
         });
 
-    // We can't switch to preferred languages, though, until the data is loaded.
+    // We can't switch to preferred languages, though, until the data is
+    // loaded.
     shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_CURRENT_DATA,
         this.loadEventManager_,
@@ -2620,9 +2325,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     } else if (mediaElement.preload == 'none') {
       shaka.log.alwaysWarn(
           'With <video preload="none">, the browser will not load anything ' +
-          'until play() is called. We are unable to measure load latency in ' +
-          'a meaningful way, and we cannot provide track info yet. Please do ' +
-          'not use preload="none" with Shaka Player.');
+          'until play() is called. We are unable to measure load latency ' +
+          'in a meaningful way, and we cannot provide track info yet. ' +
+          'Please do not use preload="none" with Shaka Player.');
       // We can't wait for an event load loadedmetadata, since that will be
       // blocked until a user interaction.  So resolve the Promise now.
       fullyLoaded.resolve();
@@ -2632,21 +2337,37 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.reject(this.videoErrorToShakaError_());
     });
 
-    return new shaka.util.AbortableOperation(fullyLoaded, /* onAbort= */ () => {
-      const abortedError = new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.PLAYER,
-          shaka.util.Error.Code.OPERATION_ABORTED);
-      fullyLoaded.reject(abortedError);
-      return Promise.resolve();  // Abort complete.
-    }).chain(() => {
-      if (this.isLive() && this.config_.streaming.liveSync) {
-        const onTimeUpdate = () => this.onTimeUpdate_();
-        this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
+    await fullyLoaded;
+
+    const isLive = this.isLive();
+
+    if (isLive && this.config_.streaming.liveSync) {
+      const onTimeUpdate = () => this.onTimeUpdate_();
+      this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
+    } else if (!isLive) {
+      const onVideoProgress = () => this.onVideoProgress_();
+      this.loadEventManager_.listen(
+          mediaElement, 'timeupdate', onVideoProgress);
+      this.onVideoProgress_();
+    }
+
+    if (this.adManager_) {
+      this.adManager_.onManifestUpdated(isLive);
+      // There is no good way to detect when the manifest has been updated,
+      // so we use seekRange().end so we can tell when it has been updated.
+      if (isLive) {
+        let prevSeekRangeEnd = this.seekRange().end;
+        this.loadEventManager_.listen(mediaElement, 'progress', () => {
+          const newSeekRangeEnd = this.seekRange().end;
+          if (prevSeekRangeEnd != newSeekRangeEnd) {
+            this.adManager_.onManifestUpdated(this.isLive());
+            prevSeekRangeEnd = newSeekRangeEnd;
+          }
+        });
       }
+    }
 
-      this.fullyLoaded_ = true;
-    });
+    this.fullyLoaded_ = true;
   }
 
   /**
@@ -2839,6 +2560,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Releases all of the mutexes of the player. Meant for use by the tests.
+   * @export
+   */
+  releaseAllMutexes() {
+    this.mutex_.releaseAll();
+  }
+
   /**
    * Create a new DrmEngine instance. This may be replaced by tests to create
    * fake instances. Configuration and initialization will be handled after
@@ -2859,13 +2588,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!shaka.net.NetworkingEngine}
    */
   createNetworkingEngine() {
-    /** @type {function(number, number)} */
-    const onProgressUpdated_ = (deltaTimeMs, bytesDownloaded) => {
+    /** @type {function(number, number, boolean)} */
+    const onProgressUpdated_ = (deltaTimeMs, bytesDownloaded, allowSwitch) => {
       // In some situations, such as during offline storage, the abr manager
       // might not yet exist. Therefore, we need to check if abr manager has
       // been initialized before using it.
       if (this.abrManager_) {
-        this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
+        this.abrManager_.segmentDownloaded(
+            deltaTimeMs, bytesDownloaded, allowSwitch);
       }
     };
     /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
@@ -2894,8 +2624,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.cmcdManager_.applyData(type, request, context);
     };
 
+
+    const onRetry_ = (type, context, newUrl, oldUrl) => {
+      if (this.parser_ && this.parser_.banLocation) {
+        this.parser_.banLocation(oldUrl);
+      }
+    };
+
     return new shaka.net.NetworkingEngine(
-        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_, onRequest_);
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_, onRequest_,
+        onRetry_);
   }
 
   /**
@@ -2979,18 +2717,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * Initialize and start the buffering system (observer and timer) so that we
    * can monitor our buffer lead during playback.
    *
+   * @param {!HTMLMediaElement} mediaElement
    * @param {number} rebufferingGoal
    * @private
    */
-  startBufferManagement_(rebufferingGoal) {
+  startBufferManagement_(mediaElement, rebufferingGoal) {
     goog.asserts.assert(
         !this.bufferObserver_,
         'No buffering observer should exist before initialization.');
 
-    goog.asserts.assert(
-        !this.bufferPoller_,
-        'No buffer timer should exist before initialization.');
-
     // Give dummy values, will be updated below.
     this.bufferObserver_ = new shaka.media.BufferingObserver(1, 2);
 
@@ -3000,12 +2735,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.updateBufferingSettings_(rebufferingGoal);
     this.updateBufferState_();
 
-    // TODO: We should take some time to look into the effects of our
-    //       quarter-second refresh practice. We often use a quarter-second
-    //       but we have no documentation about why.
-    this.bufferPoller_ = new shaka.util.Timer(() => {
-      this.pollBufferState_();
-    }).tickEvery(/* seconds= */ 0.25);
+    this.loadEventManager_.listen(mediaElement, 'waiting',
+        (e) => this.pollBufferState_());
+    this.loadEventManager_.listen(mediaElement, 'stalled',
+        (e) => this.pollBufferState_());
+    this.loadEventManager_.listen(mediaElement, 'canplaythrough',
+        (e) => this.pollBufferState_());
+    this.loadEventManager_.listen(mediaElement, 'progress',
+        (e) => this.pollBufferState_());
   }
 
   /**
@@ -3077,16 +2814,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {!shaka.extern.TextDisplayer} textDisplayer
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)}
    *  onMetadata
-   * @param {shaka.lcevc.Dil} lcevcDil
+   * @param {shaka.lcevc.Dec} lcevcDec
    *
    * @return {!shaka.media.MediaSourceEngine}
    */
-  createMediaSourceEngine(mediaElement, textDisplayer, onMetadata, lcevcDil) {
+  createMediaSourceEngine(mediaElement, textDisplayer, onMetadata, lcevcDec) {
     return new shaka.media.MediaSourceEngine(
         mediaElement,
         textDisplayer,
         onMetadata,
-        lcevcDil);
+        lcevcDec);
   }
 
   /**
@@ -3580,17 +3317,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /**
    * Get the range of time (in seconds) that seeking is allowed. If the player
-   * has not loaded content, this will return a range from 0 to 0.
+   * has not loaded content and the manifest is HLS, this will return a range
+   * from 0 to 0.
    *
    * @return {{start: number, end: number}}
    * @export
    */
   seekRange() {
-    if (!this.fullyLoaded_) {
-      return {'start': 0, 'end': 0};
-    }
-
     if (this.manifest_) {
+      // With HLS lazy-loading, there were some situations where the manifest
+      // had partially loaded, enough to move onto further load stages, but no
+      // segments had been loaded, so the timeline is still unknown.
+      // See: https://github.com/shaka-project/shaka-player/pull/4590
+      if (!this.fullyLoaded_ &&
+          this.manifest_.type == shaka.media.ManifestParser.HLS) {
+        return {'start': 0, 'end': 0};
+      }
       const timeline = this.manifest_.presentationTimeline;
 
       return {
@@ -3894,13 +3636,82 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   getImageTracks() {
+    const StreamUtils = shaka.util.StreamUtils;
+    let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
     if (this.manifest_) {
-      const imageStreams = this.manifest_.imageStreams;
-      const StreamUtils = shaka.util.StreamUtils;
-      return imageStreams.map((image) => StreamUtils.imageStreamToTrack(image));
-    } else {
-      return [];
+      imageStreams = this.manifest_.imageStreams;
+    }
+    return imageStreams.map((image) => StreamUtils.imageStreamToTrack(image));
+  }
+
+  /**
+   * Returns Thumbnail objects for each thumbnail for a given image track ID.
+   *
+   * If the player has not loaded content, this will return a null.
+   *
+   * @param {number} trackId
+   * @return {!Promise.<?Array<!shaka.extern.Thumbnail>>}
+   * @export
+   */
+  async getAllThumbnails(trackId) {
+    if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
+        this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
+      return null;
+    }
+    let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
+    if (this.manifest_) {
+      imageStreams = this.manifest_.imageStreams;
+    }
+    const imageStream = imageStreams.find(
+        (stream) => stream.id == trackId);
+    if (!imageStream) {
+      return null;
+    }
+    if (!imageStream.segmentIndex) {
+      await imageStream.createSegmentIndex();
+    }
+    const promises = [];
+    imageStream.segmentIndex.forEachTopLevelReference((reference) => {
+      const dimensions = this.parseTilesLayout_(
+          reference.getTilesLayout() || imageStream.tilesLayout);
+      if (dimensions) {
+        const numThumbnails = dimensions.rows * dimensions.columns;
+        const duration = reference.trueEndTime - reference.startTime;
+        for (let i = 0; i < numThumbnails; i++) {
+          const sampleTime = reference.startTime + duration * i / numThumbnails;
+          promises.push(this.getThumbnails(trackId, sampleTime));
+        }
+      }
+    });
+    const thumbnails = await Promise.all(promises);
+    return thumbnails.filter((t) => t);
+  }
+
+  /**
+   * Parses a tiles layout.
+   *
+   * @param {string|undefined} tilesLayout
+   * @return {?{
+   *   columns: number,
+   *   rows: number
+   * }}
+   * @private
+   */
+  parseTilesLayout_(tilesLayout) {
+    if (!tilesLayout) {
+      return null;
+    }
+    // This expression is used to detect one or more numbers (0-9) followed
+    // by an x and after one or more numbers (0-9)
+    const match = /(\d+)x(\d+)/.exec(tilesLayout);
+    if (!match) {
+      shaka.log.warning('Tiles layout does not contain a valid format ' +
+          ' (columns x rows)');
+      return null;
     }
+    const columns = parseInt(match[1], 10);
+    const rows = parseInt(match[2], 10);
+    return {columns, rows};
   }
 
   /**
@@ -3914,84 +3725,83 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   async getThumbnails(trackId, time) {
+    if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
+        this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
+      return null;
+    }
+    let imageStreams = this.externalSrcEqualsThumbnailsStreams_;
     if (this.manifest_) {
-      const imageStream = this.manifest_.imageStreams.find(
-          (stream) => stream.id == trackId);
-      if (!imageStream) {
-        return null;
-      }
-      if (!imageStream.segmentIndex) {
-        await imageStream.createSegmentIndex();
-      }
-      const referencePosition = imageStream.segmentIndex.find(time);
-      if (referencePosition == null) {
-        return null;
-      }
-      const reference = imageStream.segmentIndex.get(referencePosition);
-      const tilesLayout =
-          reference.getTilesLayout() || imageStream.tilesLayout;
-      // This expression is used to detect one or more numbers (0-9) followed
-      // by an x and after one or more numbers (0-9)
-      const match = /(\d+)x(\d+)/.exec(tilesLayout);
-      if (!match) {
-        shaka.log.warning('Tiles layout does not contain a valid format ' +
-            ' (columns x rows)');
-        return null;
-      }
-      const fullImageWidth = imageStream.width || 0;
-      const fullImageHeight = imageStream.height || 0;
-      const columns = parseInt(match[1], 10);
-      const rows = parseInt(match[2], 10);
-      let width = fullImageWidth / columns;
-      let height = fullImageHeight / rows;
-      const totalImages = columns * rows;
-      const segmentDuration = reference.trueEndTime - reference.startTime;
-      const thumbnailDuration =
-          reference.getTileDuration() || (segmentDuration / totalImages);
-      let thumbnailTime = reference.startTime;
-      let positionX = 0;
-      let positionY = 0;
-      // If the number of images in the segment is greater than 1, we have to
-      // find the correct image. For that we will return to the app the
-      // coordinates of the position of the correct image.
-      // Image search is always from left to right and top to bottom.
-      // Note: The time between images within the segment is always
-      // equidistant.
-      //
-      // Eg: Total images 5, tileLayout 5x1, segmentDuration 5, thumbnailTime 2
-      // positionX = 0.4 * fullImageWidth
-      // positionY = 0
-      if (totalImages > 1) {
-        const thumbnailPosition =
-            Math.floor((time - reference.startTime) / thumbnailDuration);
-        thumbnailTime = reference.startTime +
-            (thumbnailPosition * thumbnailDuration);
-        positionX = (thumbnailPosition % columns) * width;
-        positionY = Math.floor(thumbnailPosition / columns) * height;
-      }
-      let sprite = false;
-      const thumbnailSprite = reference.getThumbnailSprite();
-      if (thumbnailSprite) {
-        sprite = true;
-        height = thumbnailSprite.height;
-        positionX = thumbnailSprite.positionX;
-        positionY = thumbnailSprite.positionY;
-        width = thumbnailSprite.width;
-      }
-      return {
-        imageHeight: fullImageHeight,
-        imageWidth: fullImageWidth,
-        height: height,
-        positionX: positionX,
-        positionY: positionY,
-        startTime: thumbnailTime,
-        duration: thumbnailDuration,
-        uris: reference.getUris(),
-        width: width,
-        sprite: sprite,
-      };
+      imageStreams = this.manifest_.imageStreams;
+    }
+    const imageStream = imageStreams.find(
+        (stream) => stream.id == trackId);
+    if (!imageStream) {
+      return null;
+    }
+    if (!imageStream.segmentIndex) {
+      await imageStream.createSegmentIndex();
+    }
+    const referencePosition = imageStream.segmentIndex.find(time);
+    if (referencePosition == null) {
+      return null;
+    }
+    const reference = imageStream.segmentIndex.get(referencePosition);
+    const dimensions = this.parseTilesLayout_(
+        reference.getTilesLayout() || imageStream.tilesLayout);
+    if (!dimensions) {
+      return null;
+    }
+    const fullImageWidth = imageStream.width || 0;
+    const fullImageHeight = imageStream.height || 0;
+    let width = fullImageWidth / dimensions.columns;
+    let height = fullImageHeight / dimensions.rows;
+    const totalImages = dimensions.columns * dimensions.rows;
+    const segmentDuration = reference.trueEndTime - reference.startTime;
+    const thumbnailDuration =
+        reference.getTileDuration() || (segmentDuration / totalImages);
+    let thumbnailTime = reference.startTime;
+    let positionX = 0;
+    let positionY = 0;
+    // If the number of images in the segment is greater than 1, we have to
+    // find the correct image. For that we will return to the app the
+    // coordinates of the position of the correct image.
+    // Image search is always from left to right and top to bottom.
+    // Note: The time between images within the segment is always
+    // equidistant.
+    //
+    // Eg: Total images 5, tileLayout 5x1, segmentDuration 5, thumbnailTime 2
+    // positionX = 0.4 * fullImageWidth
+    // positionY = 0
+    if (totalImages > 1) {
+      const thumbnailPosition =
+          Math.floor((time - reference.startTime) / thumbnailDuration);
+      thumbnailTime = reference.startTime +
+          (thumbnailPosition * thumbnailDuration);
+      positionX = (thumbnailPosition % dimensions.columns) * width;
+      positionY = Math.floor(thumbnailPosition / dimensions.columns) * height;
+    }
+    let sprite = false;
+    const thumbnailSprite = reference.getThumbnailSprite();
+    if (thumbnailSprite) {
+      sprite = true;
+      height = thumbnailSprite.height;
+      positionX = thumbnailSprite.positionX;
+      positionY = thumbnailSprite.positionY;
+      width = thumbnailSprite.width;
     }
-    return null;
+    return {
+      segment: reference,
+      imageHeight: fullImageHeight,
+      imageWidth: fullImageWidth,
+      height: height,
+      positionX: positionX,
+      positionY: positionY,
+      startTime: thumbnailTime,
+      duration: thumbnailDuration,
+      uris: reference.getUris(),
+      width: width,
+      sprite: sprite,
+    };
   }
 
   /**
@@ -4108,7 +3918,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // When track is selected, back-propagate the language to
       // currentAudioLanguage_.
       this.currentAdaptationSetCriteria_ = new shaka.media.ExampleBasedCriteria(
-          variant);
+          variant,
+          this.config_.mediaSource.codecSwitchingStrategy,
+          this.config_.manifest.dash.enableAudioGroups);
 
       // Update AbrManager variants to match these new settings.
       this.updateAbrManagerVariants_();
@@ -4184,8 +3996,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   selectAudioLanguage(language, role, channelsCount = 0, safeMargin = 0) {
     if (this.manifest_ && this.playhead_) {
       this.currentAdaptationSetCriteria_ =
-          new shaka.media.PreferenceBasedCriteria(language, role || '',
-              channelsCount, /* hdrLevel= */ '', /* label= */ '');
+          new shaka.media.PreferenceBasedCriteria(
+              language,
+              role || '',
+              channelsCount,
+              /* hdrLevel= */ '',
+              /* videoLayout= */ '',
+              /* label= */ '',
+              this.config_.mediaSource.codecSwitchingStrategy,
+              this.config_.manifest.dash.enableAudioGroups);
 
       const diff = (a, b) => {
         if (!a.video && !b.video) {
@@ -4302,7 +4121,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // label have the same language.
       this.currentAdaptationSetCriteria_ =
           new shaka.media.PreferenceBasedCriteria(
-              firstVariantWithLabel.language, '', 0, '', label);
+              firstVariantWithLabel.language,
+              /* role= */ '',
+              /* channelCount= */ 0,
+              /* hdrLevel= */ '',
+              /* videoLayout= */ '',
+              label,
+              this.config_.mediaSource.codecSwitchingStrategy,
+              this.config_.manifest.dash.enableAudioGroups);
 
       this.chooseVariantAndSwitch_(clearBuffer, safeMargin);
     } else if (this.video_ && this.video_.audioTracks) {
@@ -4330,7 +4156,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   isTextTrackVisible() {
     const expected = this.isTextVisible_;
 
-    if (this.mediaSourceEngine_) {
+    if (this.mediaSourceEngine_ &&
+        this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
       // Make sure our values are still in-sync.
       const actual = this.mediaSourceEngine_.getTextDisplayer().isTextVisible();
       goog.asserts.assert(
@@ -4371,6 +4198,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   getChapters(language) {
+    if (!this.video_ || !this.video_.src || !this.video_.textTracks) {
+      return [];
+    }
     const LanguageUtils = shaka.util.LanguageUtils;
     const inputlanguage = LanguageUtils.normalize(language);
     const chaptersTracks = this.getChaptersTracks_();
@@ -4529,22 +4359,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return null;
     }
 
-    const walkerPayload = this.walker_.getCurrentPayload();
-
     let presentationTime = 0;
     if (this.playhead_) {
       presentationTime = this.playhead_.getTime();
-    } else if (walkerPayload) {
-      if (walkerPayload.startTime == null) {
-        // A live stream with no requested start time and no playhead yet.  We
-        // would start at the live edge, but we don't have that yet, so return
-        // the current date & time.
-        return new Date();
-      } else {
-        // A specific start time has been requested.  This is what Playhead will
-        // use once it is created.
-        presentationTime = walkerPayload.startTime;
-      }
+    } else if (this.startTime_ == null) {
+      // A live stream with no requested start time and no playhead yet.  We
+      // would start at the live edge, but we don't have that yet, so return
+      // the current date & time.
+      return new Date();
+    } else {
+      // A specific start time has been requested.  This is what Playhead will
+      // use once it is created.
+      presentationTime = this.startTime_;
     }
 
     if (this.manifest_) {
@@ -4759,9 +4585,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     let adCuePoints = [];
     if (this.adManager_) {
-      try {
-        adCuePoints = this.adManager_.getServerSideCuePoints();
-      } catch (error) {}
+      adCuePoints = this.adManager_.getCuePoints();
     }
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
@@ -4792,7 +4616,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    const duration = this.manifest_.presentationTimeline.getDuration();
+    let duration = this.video_.duration;
+    if (this.manifest_) {
+      duration = this.manifest_.presentationTimeline.getDuration();
+    }
     if (duration == Infinity) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.RECOVERABLE,
@@ -4816,6 +4643,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const stream = {
       id: this.nextExternalStreamId_++,
       originalId: null,
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: shaka.media.SegmentIndex.forSingleSegment(
           /* startTime= */ 0,
@@ -4842,6 +4670,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       closedCaptions: null,
       accessibilityPurpose: null,
       external: true,
+      fastSwitching: false,
     };
 
     const fullMimeType = shaka.util.MimeUtils.getFullType(
@@ -4885,14 +4714,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           shaka.util.Error.Code.CONTENT_NOT_LOADED);
     }
 
-    if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
-      shaka.log.error('Cannot add this thumbnail track when loaded with src=');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.TEXT,
-          shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_SRC_EQUALS);
-    }
-
     if (!mimeType) {
       mimeType = await this.getTextMimetype_(uri);
     }
@@ -4906,8 +4727,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-
-    const duration = this.manifest_.presentationTimeline.getDuration();
+    let duration = this.video_.duration;
+    if (this.manifest_) {
+      duration = this.manifest_.presentationTimeline.getDuration();
+    }
     if (duration == Infinity) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.RECOVERABLE,
@@ -4937,7 +4760,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       vttOffset: 0,
     };
     const data = shaka.util.BufferUtils.toUint8(buffer);
-    const cues = TextParser.parseMedia(data, time);
+    const cues = TextParser.parseMedia(data, time, uri);
 
     const references = [];
     for (const cue of cues) {
@@ -4972,6 +4795,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const stream = {
       id: this.nextExternalStreamId_++,
       originalId: null,
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: new shaka.media.SegmentIndex(references),
       mimeType: mimeType || '',
@@ -4996,9 +4820,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       tilesLayout: '1x1',
       accessibilityPurpose: null,
       external: true,
+      fastSwitching: false,
     };
 
-    this.manifest_.imageStreams.push(stream);
+    if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
+      this.externalSrcEqualsThumbnailsStreams_.push(stream);
+    } else {
+      this.manifest_.imageStreams.push(stream);
+    }
     this.onTracksChanged_();
     return shaka.util.StreamUtils.imageStreamToTrack(stream);
   }
@@ -5033,9 +4862,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     let adCuePoints = [];
     if (this.adManager_) {
-      try {
-        adCuePoints = this.adManager_.getServerSideCuePoints();
-      } catch (error) {}
+      adCuePoints = this.adManager_.getCuePoints();
     }
 
     /** @type {!HTMLTrackElement} */
@@ -5062,6 +4889,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         });
       });
 
+      this.onTracksChanged_();
+
       return chaptersTrack;
     }
 
@@ -5080,19 +4909,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   async getTextMimetype_(uri) {
-    // Try using the uri extension.
-    const extension = shaka.media.ManifestParser.getExtension(uri);
-    let mimeType = shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_[extension];
-
-    if (mimeType) {
-      return mimeType;
-    }
-
+    let mimeType;
     try {
       goog.asserts.assert(
           this.networkingEngine_, 'Need networking engine.');
       // eslint-disable-next-line require-atomic-updates
-      mimeType = await shaka.media.ManifestParser.getMimeType(uri,
+      mimeType = await shaka.net.NetworkingUtils.getMimeType(uri,
           this.networkingEngine_,
           this.config_.streaming.retryParameters);
     } catch (error) {}
@@ -5103,12 +4925,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     shaka.log.error(
         'The mimeType has not been provided and it could not be deduced ' +
-        'from its extension.');
+        'from its uri.');
     throw new shaka.util.Error(
         shaka.util.Error.Severity.RECOVERABLE,
         shaka.util.Error.Category.TEXT,
         shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
-        extension);
+        uri);
   }
 
   /**
@@ -5197,7 +5019,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         vttOffset: 0,
       };
       const data = shaka.util.BufferUtils.toUint8(buffer);
-      const cues = obj.parseMedia(data, time);
+      const cues = obj.parseMedia(data, time, /* uri= */ null);
       return shaka.text.WebVttGenerator.convert(cues, adCuePoints);
     }
     throw new shaka.util.Error(
@@ -5316,7 +5138,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         return new shaka.text.UITextDisplayer(
             this.video_, this.videoContainer_);
       } else {
-        return new shaka.text.SimpleTextDisplayer(this.video_);
+        // eslint-disable-next-line no-restricted-syntax
+        if (HTMLMediaElement.prototype.addTextTrack) {
+          return new shaka.text.SimpleTextDisplayer(this.video_);
+        } else {
+          shaka.log.warning('Text tracks are not supported by the ' +
+                            'browser, disabling.');
+          return new shaka.text.StubTextDisplayer();
+        }
       }
     };
     return config;
@@ -5396,6 +5225,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             const textStream = {
               id: this.nextExternalStreamId_++,  // A globally unique ID.
               originalId: id, // The CC ID string, like 'CC1', 'CC3', etc.
+              groupId: null,
               createSegmentIndex: () => Promise.resolve(),
               segmentIndex,
               mimeType,
@@ -5419,6 +5249,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               closedCaptions: null,
               accessibilityPurpose: null,
               external: false,
+              fastSwitching: false,
             };
             manifest.textStreams.push(textStream);
             closedCaptionsSet.add(id);
@@ -5447,14 +5278,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   async filterManifestWithStreamUtils_(manifest) {
     goog.asserts.assert(manifest, 'Manifest should exist!');
-    goog.asserts.assert(this.video_, 'Must not be destroyed');
-
-    /** @type {?shaka.extern.Variant} */
-    const currentVariant = this.streamingEngine_ ?
-        this.streamingEngine_.getCurrentVariant() : null;
-
-    await shaka.util.StreamUtils.filterManifest(
-        this.drmEngine_, currentVariant, manifest);
+    await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest);
     this.checkPlayableVariants_(manifest);
   }
 
@@ -5511,21 +5335,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
-  /**
-   * @private
-   */
-  filterManifestByCurrentVariant_() {
-    goog.asserts.assert(this.manifest_, 'Manifest should be valid');
-    goog.asserts.assert(this.streamingEngine_,
-        'StreamingEngine should be valid');
-
-    const currentVariant = this.streamingEngine_ ?
-        this.streamingEngine_.getCurrentVariant() : null;
-    shaka.util.StreamUtils.filterManifestByCurrentVariant(currentVariant,
-        this.manifest_);
-    this.checkPlayableVariants_(this.manifest_);
-  }
-
   /**
    * @param {shaka.extern.Variant} initialVariant
    * @param {number} time
@@ -5594,7 +5403,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const loaded = this.stats_ && this.bufferObserver_ && this.playhead_;
 
     if (loaded) {
-      this.playRateController_.setBuffering(isBuffering);
       if (this.cmcdManager_) {
         this.cmcdManager_.setBuffering(isBuffering);
       }
@@ -5661,14 +5469,20 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const history = this.stats_.getStateHistory();
 
+    let updateState = 'playing';
     if (this.bufferObserver_.getState() == State.STARVING) {
-      history.update('buffering');
+      updateState = 'buffering';
     } else if (this.video_.paused) {
-      history.update('paused');
+      updateState = 'paused';
     } else if (this.video_.ended) {
-      history.update('ended');
-    } else {
-      history.update('playing');
+      updateState = 'ended';
+    }
+    const stateChanged = history.update(updateState);
+
+    if (stateChanged) {
+      const eventName = shaka.util.FakeEvent.EventName.StateChanged;
+      const data = (new Map()).set('newstate', updateState);
+      this.dispatchEvent(this.makeEvent_(eventName, data));
     }
   }
 
@@ -5709,6 +5523,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
     }
 
+    let liveSyncMinLatency;
+    let liveSyncMinPlaybackRate;
+    if (this.config_.streaming.liveSync) {
+      liveSyncMinLatency = this.config_.streaming.liveSyncMinLatency;
+      liveSyncMinPlaybackRate = this.config_.streaming.liveSyncMinPlaybackRate;
+    } else {
+      // serviceDescription must override if it is defined in the MPD and
+      // liveSync configuration is not set.
+      if (this.manifest_ && this.manifest_.serviceDescription) {
+        liveSyncMinLatency = this.manifest_.serviceDescription.minLatency ||
+          this.config_.streaming.liveSyncMinLatency;
+        liveSyncMinPlaybackRate =
+          this.manifest_.serviceDescription.minPlaybackRate ||
+          this.config_.streaming.liveSyncMinPlaybackRate;
+      }
+    }
+
     const playbackRate = this.video_.playbackRate;
     const latency = seekRange.end - this.video_.currentTime;
     let offset = 0;
@@ -5732,11 +5563,62 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           'Updating playbackRate to ' + liveSyncPlaybackRate);
         this.trickPlay(liveSyncPlaybackRate);
       }
-    } else if (playbackRate !== 1 && playbackRate !== 0) {
+    } else if (liveSyncMinLatency && liveSyncMinPlaybackRate &&
+        (latency - offset) < liveSyncMinLatency) {
+      if (playbackRate != liveSyncMinPlaybackRate) {
+        shaka.log.debug('Latency (' + latency + 's) ' +
+          'is smaller than liveSyncMinLatency (' + liveSyncMinLatency + 's). ' +
+          'Updating playbackRate to ' + liveSyncMinPlaybackRate);
+        this.trickPlay(liveSyncMinPlaybackRate);
+      }
+    } else if (playbackRate !== this.playRateController_.getDefaultRate()) {
       this.cancelTrickPlay();
     }
   }
 
+  /**
+   * Callback for video progress events
+   *
+   * @private
+   */
+  onVideoProgress_() {
+    if (!this.video_) {
+      return;
+    }
+    let hasNewCompletionPercent = false;
+    const completionRatio = this.video_.currentTime / this.video_.duration;
+    if (!isNaN(completionRatio)) {
+      const percent = Math.round(100 * completionRatio);
+      if (isNaN(this.completionPercent_)) {
+        this.completionPercent_ = percent;
+        hasNewCompletionPercent = true;
+      } else {
+        const newCompletionPercent = Math.max(this.completionPercent_, percent);
+        if (this.completionPercent_ != newCompletionPercent) {
+          this.completionPercent_ = newCompletionPercent;
+          hasNewCompletionPercent = true;
+        }
+      }
+    }
+    if (hasNewCompletionPercent) {
+      let event;
+      if (this.completionPercent_ == 0) {
+        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Started);
+      } else if (this.completionPercent_ == 25) {
+        event = this.makeEvent_(shaka.util.FakeEvent.EventName.FirstQuartile);
+      } else if (this.completionPercent_ == 50) {
+        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Midpoint);
+      } else if (this.completionPercent_ == 75) {
+        event = this.makeEvent_(shaka.util.FakeEvent.EventName.ThirdQuartile);
+      } else if (this.completionPercent_ == 100) {
+        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Complete);
+      }
+      if (event) {
+        this.dispatchEvent(event);
+      }
+    }
+  }
+
   /**
    * Callback from Playhead.
    *
@@ -5791,12 +5673,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    *
    * On error, this dispatches an error event and returns null.
    *
+   * @param {boolean=} initialSelection
    * @return {?shaka.extern.Variant}
    * @private
    */
-  chooseVariant_() {
+  chooseVariant_(initialSelection = false) {
     if (this.updateAbrManagerVariants_()) {
-      return this.abrManager_.chooseVariant();
+      return this.abrManager_.chooseVariant(initialSelection);
     } else {
       return null;
     }
@@ -6132,8 +6015,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    if (this.lcevcDil_) {
-      this.lcevcDil_.updateVariant(to);
+    if (this.lcevcDec_) {
+      this.lcevcDec_.updateVariant(to, this.getManifestType());
     }
     const event =
         this.makeEvent_(shaka.util.FakeEvent.EventName.Adaptation, data);
@@ -6163,8 +6046,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    if (this.lcevcDil_) {
-      this.lcevcDil_.updateVariant(to);
+    if (this.lcevcDec_) {
+      this.lcevcDec_.updateVariant(to, this.getManifestType());
     }
 
     const event =
@@ -6445,6 +6328,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.KeyStatusChanged);
+    this.dispatchEvent(event);
+
     const keyIds = Object.keys(keyStatusMap);
     if (keyIds.length == 0) {
       shaka.log.warning(
@@ -6833,8 +6720,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Because Safari's native HLS reports slightly inaccurate values for
     // bufferEnd here, we use a fudge factor.  Without this, we can end up in a
     // buffering state at the end of the stream.  See issue #2117.
-    // TODO: Try to remove the fudge here once we no longer manage buffering
-    // state above the browser with playbackRate=0.
     const fudge = 1;  // 1000 ms
     return bufferEnd != null && bufferEnd >= this.video_.duration - fudge;
   }
@@ -6851,290 +6736,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.util.Error.Category.PLAYER,
         shaka.util.Error.Code.LOAD_INTERRUPTED);
   }
-
-  /**
-   * Key
-   * ----------------------
-   * D   : Detach Node
-   * A   : Attach Node
-   * MS  : Media Source Node
-   * P   : Manifest Parser Node
-   * M   : Manifest Node
-   * DRM : Drm Engine Node
-   * L   : Load Node
-   * U   : Unloading Node
-   * SRC : Src Equals Node
-   *
-   * Graph Topology
-   * ----------------------
-   *
-   *        [SRC]-----+
-   *         ^        |
-   *         |        v
-   * [D]<-->[A]<-----[U]
-   *         |        ^
-   *         v        |
-   *        [MS]------+
-   *         |        |
-   *         v        |
-   *        [P]-------+
-   *         |        |
-   *         v        |
-   *        [M]-------+
-   *         |        |
-   *         v        |
-   *        [DRM]-----+
-   *         |        |
-   *         v        |
-   *        [L]-------+
-   *
-   * @param {!shaka.routing.Node} currentlyAt
-   * @param {shaka.routing.Payload} currentlyWith
-   * @param {!shaka.routing.Node} wantsToBeAt
-   * @param {shaka.routing.Payload} wantsToHave
-   * @return {?shaka.routing.Node}
-   * @private
-   */
-  getNextStep_(currentlyAt, currentlyWith, wantsToBeAt, wantsToHave) {
-    let next = null;
-
-    // Detach is very simple, either stay in detach (because |detach| was called
-    // while in detached) or go somewhere that requires us to attach to an
-    // element.
-    if (currentlyAt == this.detachNode_) {
-      next = wantsToBeAt == this.detachNode_ ?
-             this.detachNode_ :
-             this.attachNode_;
-    }
-
-    if (currentlyAt == this.attachNode_) {
-      next = this.getNextAfterAttach_(wantsToBeAt, currentlyWith, wantsToHave);
-    }
-
-    if (currentlyAt == this.mediaSourceNode_) {
-      next = this.getNextAfterMediaSource_(
-          wantsToBeAt, currentlyWith, wantsToHave);
-    }
-
-    if (currentlyAt == this.parserNode_) {
-      next = this.getNextMatchingAllDependencies_(
-          /* destination= */ this.loadNode_,
-          /* next= */ this.manifestNode_,
-          /* reset= */ this.unloadNode_,
-          /* goingTo= */ wantsToBeAt,
-          /* has= */ currentlyWith,
-          /* wants= */ wantsToHave);
-    }
-
-    if (currentlyAt == this.manifestNode_) {
-      next = this.getNextMatchingAllDependencies_(
-          /* destination= */ this.loadNode_,
-          /* next= */ this.drmNode_,
-          /* reset= */ this.unloadNode_,
-          /* goingTo= */ wantsToBeAt,
-          /* has= */ currentlyWith,
-          /* wants= */ wantsToHave);
-    }
-
-    // For DRM, we have two options "load" or "unload". If all our constraints
-    // are met, we can go to "load". If anything is off, we must go back to
-    // "unload" to reset.
-    if (currentlyAt == this.drmNode_) {
-      next = this.getNextMatchingAllDependencies_(
-          /* destination= */ this.loadNode_,
-          /* next= */ this.loadNode_,
-          /* reset= */ this.unloadNode_,
-          /* goingTo= */ wantsToBeAt,
-          /* has= */ currentlyWith,
-          /* wants= */ wantsToHave);
-    }
-
-    // For DRM w/ src= playback, we only care about destination and media
-    // element.
-    if (currentlyAt == this.srcEqualsDrmNode_) {
-      if (wantsToBeAt == this.srcEqualsNode_ &&
-          currentlyWith.mediaElement == wantsToHave.mediaElement) {
-        next = this.srcEqualsNode_;
-      } else {
-        next = this.unloadNode_;
-      }
-    }
-
-    // After we load content, always go through unload because we can't safely
-    // use components after we have started playback.
-    if (currentlyAt == this.loadNode_ || currentlyAt == this.srcEqualsNode_) {
-      next = this.unloadNode_;
-    }
-
-    if (currentlyAt == this.unloadNode_) {
-      next = this.getNextAfterUnload_(wantsToBeAt, currentlyWith, wantsToHave);
-    }
-
-    goog.asserts.assert(next, 'Missing next step!');
-    return next;
-  }
-
-  /**
-   * @param {!shaka.routing.Node} goingTo
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {?shaka.routing.Node}
-   * @private
-   */
-  getNextAfterAttach_(goingTo, has, wants) {
-    // Attach and detach are the only two nodes that we can directly go
-    // back-and-forth between.
-    if (goingTo == this.detachNode_) {
-      return this.detachNode_;
-    }
-
-    // If we are going anywhere other than detach, then we need the media
-    // element to match, if they don't match, we need to go through detach
-    // first.
-    if (has.mediaElement != wants.mediaElement) {
-      return this.detachNode_;
-    }
-
-    // If we are already in attached, and someone calls |attach| again (to the
-    // same video element), we can handle the redundant request by re-entering
-    // our current state.
-    if (goingTo == this.attachNode_) {
-      return this.attachNode_;
-    }
-
-    // The next step from attached to loaded is through media source.
-    if (goingTo == this.mediaSourceNode_ || goingTo == this.loadNode_) {
-      return this.mediaSourceNode_;
-    }
-
-    // If we are going to src=, then we should set up DRM first.  This will
-    // support cases like FairPlay HLS on Safari.
-    if (goingTo == this.srcEqualsNode_) {
-      return this.srcEqualsDrmNode_;
-    }
-
-    // We are missing a rule, the null will get caught by a common check in
-    // the routing system.
-    return null;
-  }
-
-  /**
-   * @param {!shaka.routing.Node} goingTo
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {?shaka.routing.Node}
-   * @private
-   */
-  getNextAfterMediaSource_(goingTo, has, wants) {
-    // We can only go to parse manifest or unload. If we want to go to load and
-    // we have the right media element, we can go to parse manifest. If we
-    // don't, no matter where we want to go, we must go through unload.
-    if (goingTo == this.loadNode_ && has.mediaElement == wants.mediaElement) {
-      return this.parserNode_;
-    }
-
-    // Right now the unload node is responsible for tearing down all playback
-    // components (including media source). So since we have created media
-    // source, we need to unload since our dependencies are not compatible.
-    //
-    // TODO: We are structured this way to maintain a historic structure. Going
-    //       forward, there is no reason to restrict ourselves to this. Going
-    //       forward we should explore breaking apart |onUnload| and develop
-    //       more meaningful terminology around tearing down playback resources.
-    return this.unloadNode_;
-  }
-
-  /**
-   * After unload there are only two options, attached or detached. This choice
-   * is based on whether or not we have a media element. If we have a media
-   * element, then we go to attach. If we don't have a media element, we go to
-   * detach.
-   *
-   * @param {!shaka.routing.Node} goingTo
-   * @param {shaka.routing.Payload} has
-   * @param {shaka.routing.Payload} wants
-   * @return {?shaka.routing.Node}
-   * @private
-   */
-  getNextAfterUnload_(goingTo, has, wants) {
-    // If we don't want a media element, detach.
-    // If we have the wrong media element, detach.
-    // Otherwise it means we want to attach to a media element and it is safe to
-    // do so.
-    return !wants.mediaElement || has.mediaElement != wants.mediaElement ?
-           this.detachNode_ :
-           this.attachNode_;
-  }
-
-  /**
-   * A general method used to handle routing when we can either than one step
-   * toward our destination (while all our dependencies match) or go to a node
-   * that will reset us so we can try again.
-   *
-   * @param {!shaka.routing.Node} destinationNode
-   *   What |goingTo| must be for us to step toward |nextNode|. Otherwise we
-   *   will go to |resetNode|.
-   * @param {!shaka.routing.Node} nextNode
-   *   The node we will go to next if |goingTo == destinationNode| and all
-   *   dependencies match.
-   * @param {!shaka.routing.Node} resetNode
-   *   The node we will go to next if |goingTo != destinationNode| or any
-   *   dependency does not match.
-   * @param {!shaka.routing.Node} goingTo
-   *   The node that the walker is trying to go to.
-   * @param {shaka.routing.Payload} has
-   *   The payload that the walker currently has.
-   * @param {shaka.routing.Payload} wants
-   *   The payload that the walker wants to have when iy gets to |goingTo|.
-   * @return {shaka.routing.Node}
-   * @private
-   */
-  getNextMatchingAllDependencies_(destinationNode, nextNode, resetNode, goingTo,
-      has, wants) {
-    if (goingTo == destinationNode &&
-        has.mediaElement == wants.mediaElement &&
-        has.uri == wants.uri &&
-        has.mimeType == wants.mimeType) {
-      return nextNode;
-    }
-
-    return resetNode;
-  }
-
-  /**
-   * @return {shaka.routing.Payload}
-   * @private
-   */
-  static createEmptyPayload_() {
-    return {
-      mediaElement: null,
-      mimeType: null,
-      startTime: null,
-      startTimeOfLoad: NaN,
-      uri: null,
-    };
-  }
-
-  /**
-   * Using a promise, wrap the listeners returned by |Walker.startNewRoute|.
-   * This will work for most usages in |Player| but should not be used for
-   * special cases.
-   *
-   * This will connect |onCancel|, |onEnd|, |onError|, and |onSkip| with
-   * |resolve| and |reject| but will leave |onStart| unset.
-   *
-   * @param {shaka.routing.Walker.Listeners} listeners
-   * @return {!Promise}
-   * @private
-   */
-  wrapWalkerListenersWithPromise_(listeners) {
-    return new Promise((resolve, reject) => {
-      listeners.onCancel = () => reject(this.createAbortLoadError_());
-      listeners.onEnd = () => resolve();
-      listeners.onError = (e) => reject(e);
-      listeners.onSkip = () => reject(this.createAbortLoadError_());
-    });
-  }
 };
 
 /**
@@ -7175,7 +6776,8 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.4.3-uncompiled';
+// eslint-disable-next-line no-useless-concat
+shaka.Player.version = 'v4.6.0' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.
@@ -7202,47 +6804,6 @@ shaka.Player.supportPlugins_ = {};
 shaka.Player.adManagerFactory_ = null;
 
 
-/**
- * @const {!Object.<string, string>}
- * @private
- */
-shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_ = {
-  'mp4': 'video/mp4',
-  'm4v': 'video/mp4',
-  'm4a': 'audio/mp4',
-  'webm': 'video/webm',
-  'weba': 'audio/webm',
-  'mkv': 'video/webm', // Chromium browsers supports it.
-  'ts': 'video/mp2t',
-  'ogv': 'video/ogg',
-  'ogg': 'audio/ogg',
-  'mpg': 'video/mpeg',
-  'mpeg': 'video/mpeg',
-  'm3u8': 'application/x-mpegurl',
-  'mpd': 'application/dash+xml',
-  'mp3': 'audio/mpeg',
-  'aac': 'audio/aac',
-  'flac': 'audio/flac',
-  'wav': 'audio/wav',
-};
-
-
-/**
- * @const {!Object.<string, string>}
- * @private
- */
-shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
-  'sbv': 'text/x-subviewer',
-  'srt': 'text/srt',
-  'vtt': 'text/vtt',
-  'webvtt': 'text/vtt',
-  'ttml': 'application/ttml+xml',
-  'lrc': 'application/x-subtitle-lrc',
-  'ssa': 'text/x-ssa',
-  'ass': 'text/x-ssa',
-};
-
-
 /**
  * @const {string}
  */