shaka-player 4.7.12 → 4.8.0

package/lib/player.js

@@ -14,6 +14,7 @@ goog.require('shaka.media.AdaptationSetCriteria');
 goog.require('shaka.media.BufferingObserver');
 goog.require('shaka.media.DrmEngine');
 goog.require('shaka.media.ExampleBasedCriteria');
+goog.require('shaka.media.ManifestFilterer');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.media.MediaSourcePlayhead');
@@ -22,10 +23,12 @@ goog.require('shaka.media.PlayRateController');
 goog.require('shaka.media.Playhead');
 goog.require('shaka.media.PlayheadObserverManager');
 goog.require('shaka.media.PreferenceBasedCriteria');
+goog.require('shaka.media.PreloadManager');
 goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.RegionObserver');
 goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentIndex');
+goog.require('shaka.media.SegmentPrefetch');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.SrcEqualsPlayhead');
 goog.require('shaka.media.StreamingEngine');
@@ -494,6 +497,29 @@ goog.requireType('shaka.media.PresentationTimeline');
  */
 
 
+/**
+ * @event shaka.Player.SpatialVideoInfoEvent
+ * @description Fired when the video has spatial video info. If a previous
+ *   event was fired, this include the new info.
+ * @property {string} type
+ *   'spatialvideoinfo'
+ * @property {shaka.extern.SpatialVideoInfo} detail
+ *   An object which contains the content of the emsg box.
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.NoSpatialVideoInfoEvent
+ * @description Fired when the video no longer has spatial video information.
+ *   For it to be fired, the shaka.Player.SpatialVideoInfoEvent event must
+ *   have been previously fired.
+ * @property {string} type
+ *   'nospatialvideoinfo'
+ * @exportDoc
+ */
+
+
 /**
  * @summary The main player object for Shaka Player.
  *
@@ -635,6 +661,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {?string} */
     this.assetUri_ = null;
 
+    /** @private {?string} */
+    this.mimeType_ = null;
+
     /** @private {?number} */
     this.startTime_ = null;
 
@@ -676,6 +705,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {{width: number, height: number}} */
     this.maxHwRes_ = {width: Infinity, height: Infinity};
 
+    /** @private {!shaka.media.ManifestFilterer} */
+    this.manifestFilterer_ = new shaka.media.ManifestFilterer(
+        this.config_, this.maxHwRes_, null);
+
     /** @private {shaka.util.Stats} */
     this.stats_ = null;
 
@@ -814,7 +847,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!shaka.util.FakeEvent}
    * @private
    */
-  makeEvent_(name, data) {
+  static makeEvent_(name, data) {
     return new shaka.util.FakeEvent(name, data);
   }
 
@@ -997,7 +1030,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   makeStateChangeEvent_(nodeName) {
-    this.dispatchEvent(this.makeEvent_(
+    this.dispatchEvent(shaka.Player.makeEvent_(
         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
         /* data= */ (new Map()).set('state', nodeName)));
   }
@@ -1018,6 +1051,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       throw this.createAbortLoadError_();
     }
 
+    const noop = this.video_ && this.video_ == mediaElement;
+
     if (this.video_ && this.video_ != mediaElement) {
       await this.detach();
     }
@@ -1027,11 +1062,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     try {
-      this.makeStateChangeEvent_('attach');
+      if (!noop) {
+        this.makeStateChangeEvent_('attach');
 
-      const onError = (error) => this.onVideoError_(error);
-      this.attachEventManager_.listen(mediaElement, 'error', onError);
-      this.video_ = mediaElement;
+        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 &&
@@ -1163,7 +1200,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
       // Dispatch the unloading event.
       this.dispatchEvent(
-          this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
+          shaka.Player.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
 
       // Release the region timeline, which is created when parsing the
       // manifest.
@@ -1270,6 +1307,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
 
       this.assetUri_ = null;
+      this.mimeType_ = null;
       this.bufferObserver_ = null;
 
       if (this.manifest_) {
@@ -1324,7 +1362,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * Loads a new stream.
    * If another stream was already playing, first unloads that stream.
    *
-   * @param {string} assetUri
+   * @param {string|shaka.media.PreloadManager} assetUriOrPreloader
    * @param {?number=} startTime
    *    When <code>startTime</code> is <code>null</code> or
    *    <code>undefined</code>, playback will start at the default start time (0
@@ -1333,12 +1371,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!Promise}
    * @export
    */
-  async load(assetUri, startTime = null, mimeType) {
+  async load(assetUriOrPreloader, startTime = null, mimeType) {
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
       throw this.createAbortLoadError_();
     }
 
+    /** @type {?shaka.media.PreloadManager} */
+    let preloadManager = null;
+    let assetUri = '';
+    if (assetUriOrPreloader instanceof shaka.media.PreloadManager) {
+      preloadManager = assetUriOrPreloader;
+      assetUri = preloadManager.getAssetUri() || '';
+    } else {
+      assetUri = assetUriOrPreloader || '';
+    }
+
     // Quickly acquire the mutex, so this will wait for other top-level
     // operations.
     await this.mutex_.acquire('load');
@@ -1358,8 +1406,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // 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 = () => {
+    const detectInterruption = async () => {
       if (this.operationId_ != operationId) {
+        if (preloadManager) {
+          await preloadManager.destroy();
+        }
         throw this.createAbortLoadError_();
       }
     };
@@ -1375,37 +1426,75 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const mutexWrapOperation = async (operation, mutexIdentifier) => {
       try {
         await this.mutex_.acquire(mutexIdentifier);
-        detectInterruption();
+        await detectInterruption();
         await operation();
-        detectInterruption();
+        await detectInterruption();
+        if (preloadManager && this.config_) {
+          preloadManager.reconfigure(this.config_);
+        }
       } finally {
         this.mutex_.release();
       }
     };
 
     try {
+      if (startTime == null && preloadManager) {
+        startTime = preloadManager.getStartTime();
+      }
       this.startTime_ = startTime;
       this.fullyLoaded_ = false;
 
       // We dispatch the loading event when someone calls |load| because we want
       // to surface the user intent.
-      this.dispatchEvent(this.makeEvent_(
+      this.dispatchEvent(shaka.Player.makeEvent_(
           shaka.util.FakeEvent.EventName.Loading));
 
-      const startTimeOfLoad = Date.now() / 1000;
+      if (preloadManager) {
+        mimeType = preloadManager.getMimeType();
+      } else if (!mimeType) {
+        await mutexWrapOperation(async () => {
+          mimeType = await this.guessMimeType_(assetUri);
+        }, 'guessMimeType_');
+      }
+
+      const wasPreloaded = !!preloadManager;
+      if (!preloadManager) {
+        // For simplicity, if an asset is NOT preloaded, start an internal
+        // "preload" here without prefetch.
+        // That way, both a preload and normal load can follow the same code
+        // paths.
+        // NOTE: await preloadInner_ can be outside the mutex because it should
+        // not mutate "this".
+        preloadManager = await this.preloadInner_(
+            assetUri, startTime, mimeType, /* standardLoad= */ true);
+        if (preloadManager) {
+          preloadManager.setEventHandoffTarget(this);
+          this.stats_ = preloadManager.getStats();
+          await mutexWrapOperation(() => preloadManager.start(), 'preload');
+        } else {
+          this.stats_ = new shaka.util.Stats();
+        }
+      } else {
+        // Hook up events, so any events emitted by the preloadManager will
+        // instead be emitted by the player.
+        preloadManager.setEventHandoffTarget(this);
+        this.stats_ = preloadManager.getStats();
+      }
+      // Now, if there is no preload manager, that means that this is a src=
+      // asset.
+      const shouldUseSrcEquals = !preloadManager;
+
+      const startTimeOfLoad = preloadManager ?
+          preloadManager.getStartTimeOfLoad() : (Date.now() / 1000);
 
       // 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.stats_ =
+          preloadManager ? preloadManager.getStats() : new shaka.util.Stats();
 
       this.assetUri_ = assetUri;
+      this.mimeType_ = mimeType || null;
 
-      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!');
@@ -1421,42 +1510,475 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             await this.initializeMediaSourceEngineInner_();
           }, 'initializeMediaSourceEngineInner_');
         }
+
+        // Get manifest and associated values from preloader.
+        await mutexWrapOperation(
+            () => preloadManager.waitForManifest(), 'waitForManifest');
+        this.config_ = preloadManager.getConfiguration();
+        this.manifestFilterer_ = preloadManager.getManifestFilterer();
+        this.parserFactory_ = preloadManager.getParserFactory();
+        this.parser_ = preloadManager.receiveParser();
+        this.regionTimeline_ = preloadManager.receiveRegionTimeline();
+        this.qualityObserver_ = preloadManager.getQualityObserver();
+        this.manifest_ = preloadManager.getManifest();
+        const currentAdaptationSetCriteria =
+            preloadManager.getCurrentAdaptationSetCriteria();
+        if (currentAdaptationSetCriteria) {
+          this.currentAdaptationSetCriteria_ = currentAdaptationSetCriteria;
+        }
+        if (wasPreloaded && this.video_ && this.video_.nodeName === 'AUDIO') {
+          // Filter the variants to be audio-only after the fact.
+          // As, when preloading, we don't know if we are going to be attached
+          // to a video or audio element when we load, we have to do the auto
+          // audio-only filtering here, post-facto.
+          this.makeManifestAudioOnly_();
+          // And continue to do so in the future.
+          this.configure('manifest.disableVideo', true);
+        }
+
+        // Get drm engine from preloader, then finalize it.
+        await mutexWrapOperation(
+            () => preloadManager.waitForDrm(), 'waitForDrm');
+        this.drmEngine_ = preloadManager.receiveDrmEngine();
         await mutexWrapOperation(async () => {
-          await this.parseManifestInner_(mimeType);
-        }, 'parseManifestInner_');
-        await mutexWrapOperation(async () => {
-          await this.initializeDrmInner_();
-        }, 'initializeDrmInner_');
+          await this.drmEngine_.attach(this.video_);
+        }, 'drmEngine_.attach');
+
+        // Choose an initial variant.
+        await mutexWrapOperation(
+            () => preloadManager.waitForChooseInitialVariant(),
+            'waitForChooseInitialVariant');
+
+        // Also get the ABR manager, which has special logic related to being
+        // received.
+        const abrManagerFactory = preloadManager.getAbrManagerFactory();
+        if (abrManagerFactory) {
+          if (!this.abrManagerFactory_ ||
+              this.abrManagerFactory_ != abrManagerFactory) {
+            this.abrManager_ = preloadManager.receiveAbrManager();
+            this.abrManagerFactory_ = preloadManager.getAbrManagerFactory();
+            if (typeof this.abrManager_.setMediaElement != 'function') {
+              shaka.Deprecate.deprecateFeature(5,
+                  'AbrManager w/o setMediaElement',
+                  'Please use an AbrManager with setMediaElement function.');
+              this.abrManager_.setMediaElement = () => {};
+            }
+            if (typeof this.abrManager_.setCmsdManager != 'function') {
+              shaka.Deprecate.deprecateFeature(5,
+                  'AbrManager w/o setCmsdManager',
+                  'Please use an AbrManager with setCmsdManager function.');
+              this.abrManager_.setCmsdManager = () => {};
+            }
+            if (typeof this.abrManager_.trySuggestStreams != 'function') {
+              shaka.Deprecate.deprecateFeature(5,
+                  'AbrManager w/o trySuggestStreams',
+                  'Please use an AbrManager with trySuggestStreams function.');
+              this.abrManager_.trySuggestStreams = () => {};
+            }
+          }
+        }
+
+        // Load the asset.
+        const segmentPrefetchById =
+              preloadManager.receiveSegmentPrefetchesById();
+        const prefetchedVariant = preloadManager.getPrefetchedVariant();
         await mutexWrapOperation(async () => {
-          await this.loadInner_(startTimeOfLoad);
+          await this.loadInner_(
+              startTimeOfLoad, prefetchedVariant, segmentPrefetchById);
         }, 'loadInner_');
+        preloadManager.stopQueuingLatePhaseQueuedOperations();
       }
-      this.dispatchEvent(this.makeEvent_(
+      this.dispatchEvent(shaka.Player.makeEvent_(
           shaka.util.FakeEvent.EventName.Loaded));
     } catch (error) {
       if (error.code != shaka.util.Error.Code.LOAD_INTERRUPTED) {
         await this.unload(/* initializeMediaSource= */ false);
       }
       throw error;
+    } finally {
+      if (preloadManager) {
+        // This will cause any resources that were generated but not used to be
+        // properly destroyed or released.
+        await preloadManager.destroy();
+      }
     }
   }
 
+  /**
+   * Modifies the current manifest so that it is audio-only.
+   * @private
+   */
+  makeManifestAudioOnly_() {
+    for (const variant of this.manifest_.variants) {
+      if (variant.video) {
+        variant.video.closeSegmentIndex();
+        variant.video = null;
+      }
+      if (variant.audio && variant.audio.bandwidth) {
+        variant.bandwidth = variant.audio.bandwidth;
+      } else {
+        variant.bandwidth = 0;
+      }
+    }
+    this.manifest_.variants = this.manifest_.variants.filter((v) => {
+      return v.audio;
+    });
+  }
+
+  /**
+   * Unloads the currently playing stream, if any, and returns a PreloadManager
+   * that contains the loaded manifest of that asset, if any.
+   * Allows for the asset to be re-loaded by this player faster, in the future.
+   * When in src= mode, this unloads but does not make a PreloadManager.
+   *
+   * @param {boolean=} initializeMediaSource
+   * @param {boolean=} keepAdManager
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   * @export
+   */
+  async unloadAndSavePreload(
+      initializeMediaSource = true, keepAdManager = false) {
+    let preloadManager = null;
+    if (this.manifest_ && this.parser_ && this.parserFactory_ &&
+        this.assetUri_) {
+      let startTime = this.video_.currentTime;
+      if (this.isLive()) {
+        startTime = null;
+      }
+      // We have enough information to make a PreloadManager!
+      const startTimeOfLoad = Date.now() / 1000;
+      preloadManager = await this.makePreloadManager_(
+          this.assetUri_,
+          startTime,
+          this.mimeType_,
+          startTimeOfLoad,
+          /* allowPrefetch= */ true,
+          /* disableVideo= */ false,
+          /* allowMakeAbrManager= */ false);
+      preloadManager.attachManifest(
+          this.manifest_, this.parser_, this.parserFactory_);
+      preloadManager.attachAbrManager(
+          this.abrManager_, this.abrManagerFactory_);
+      preloadManager.attachAdaptationSetCriteria(
+          this.currentAdaptationSetCriteria_);
+      preloadManager.start();
+      // Null the manifest and manifestParser, so that they won't be shut down
+      // during unload and will continue to live inside the preloadManager.
+      this.manifest_ = null;
+      this.parser_ = null;
+      this.parserFactory_ = null;
+      // Null the abrManager and abrManagerFactory, so that they won't be shut
+      // down during unload and will continue to live inside the preloadManager.
+      this.abrManager_ = null;
+      this.abrManagerFactory_ = null;
+    }
+    await this.unload(initializeMediaSource, keepAdManager);
+    return preloadManager;
+  }
+
+  /**
+   * Starts to preload a given asset, and returns a PreloadManager object that
+   * represents that preloading process.
+   * The PreloadManager will load the manifest for that asset, as well as the
+   * initialization segment. It will not preload anything more than that;
+   * this feature is intended for reducing start-time latency, not for fully
+   * downloading assets before playing them (for that, use
+   * |shaka.offline.Storage|).
+   * You can pass that PreloadManager object in to the |load| method on this
+   * Player instance to finish loading that particular asset, or you can call
+   * the |destroy| method on the manager if the preload is no longer necessary.
+   * If this returns null rather than a PreloadManager, that indicates that the
+   * asset must be played with src=, which cannot be preloaded.
+   *
+   * @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
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   * @export
+   */
+  async preload(assetUri, startTime = null, mimeType) {
+    const preloadManager = await this.preloadInner_(
+        assetUri, startTime, mimeType);
+    if (!preloadManager) {
+      this.onError_(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.PLAYER,
+          shaka.util.Error.Code.SRC_EQUALS_PRELOAD_NOT_SUPPORTED));
+    } else {
+      preloadManager.start().catch((error) => {}); // Catch errors.
+    }
+    return preloadManager;
+  }
+
+  /**
+   * @param {string} assetUri
+   * @param {?number} startTime
+   * @param {?string=} mimeType
+   * @param {boolean=} standardLoad
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   * @private
+   */
+  async preloadInner_(assetUri, startTime, mimeType, standardLoad = false) {
+    goog.asserts.assert(this.networkingEngine_, 'Should have a net engine!');
+    goog.asserts.assert(this.config_, 'Config must not be null!');
+    const startTimeOfLoad = Date.now() / 1000;
+    if (!mimeType) {
+      mimeType = await this.guessMimeType_(assetUri);
+    }
+    const shouldUseSrcEquals = this.shouldUseSrcEquals_(assetUri, mimeType);
+    if (shouldUseSrcEquals) {
+      // We cannot preload src= content.
+      return null;
+    }
+    let disableVideo = false;
+    let allowMakeAbrManager = true;
+    if (standardLoad) {
+      if (this.abrManager_ &&
+          this.abrManagerFactory_ == this.config_.abrFactory) {
+        // If there's already an abr manager, don't make a new abr manager at
+        // all.
+        // In standardLoad mode, the abr manager isn't used for anything anyway,
+        // so it should only be created to create an abr manager for the player
+        // to use... which is unnecessary if we already have one of the right
+        // type.
+        allowMakeAbrManager = false;
+      }
+      if (this.video_ && this.video_.nodeName === 'AUDIO') {
+        disableVideo = true;
+      }
+    }
+    return this.makePreloadManager_(
+        assetUri, startTime, mimeType || null, startTimeOfLoad,
+        /* allowPrefetch= */ !standardLoad, disableVideo, allowMakeAbrManager);
+  }
+
+  /**
+   * @param {string} assetUri
+   * @param {?number} startTime
+   * @param {?string} mimeType
+   * @param {number} startTimeOfLoad
+   * @param {boolean=} allowPrefetch
+   * @param {boolean=} disableVideo
+   * @param {boolean=} allowMakeAbrManager
+   * @return {!Promise.<!shaka.media.PreloadManager>}
+   * @private
+   */
+  async makePreloadManager_(assetUri, startTime, mimeType, startTimeOfLoad,
+      allowPrefetch = true, disableVideo = false, allowMakeAbrManager = true) {
+    goog.asserts.assert(this.networkingEngine_, 'Must have net engine');
+    /** @type {?shaka.media.PreloadManager} */
+    let preloadManager = null;
+
+    const config = shaka.util.ObjectUtils.cloneObject(this.config_);
+    if (disableVideo) {
+      config.manifest.disableVideo = true;
+    }
+
+    const getPreloadManager = () => {
+      goog.asserts.assert(preloadManager, 'Must have preload manager');
+      if (preloadManager.hasBeenAttached() && preloadManager.isDestroyed()) {
+        return null;
+      }
+      return preloadManager;
+    };
+
+    const getConfig = () => {
+      if (getPreloadManager()) {
+        return getPreloadManager().getConfiguration();
+      } else {
+        return this.config_;
+      }
+    };
+
+    const setConfig = (name, value) => {
+      if (getPreloadManager()) {
+        preloadManager.configure(name, value);
+      } else {
+        this.configure(name, value);
+      }
+    };
+
+    // Avoid having to detect the resolution again if it has already been
+    // detected or set
+    if (this.maxHwRes_.width == Infinity &&
+        this.maxHwRes_.height == Infinity) {
+      const maxResolution =
+          await shaka.util.Platform.detectMaxHardwareResolution();
+      this.maxHwRes_.width = maxResolution.width;
+      this.maxHwRes_.height = maxResolution.height;
+    }
+    const manifestFilterer = new shaka.media.ManifestFilterer(
+        config, this.maxHwRes_, null);
+    const manifestPlayerInterface = {
+      networkingEngine: this.networkingEngine_,
+      filter: async (manifest) => {
+        const tracksChanged = await manifestFilterer.filterManifest(manifest);
+        if (tracksChanged) {
+          // Delay the 'trackschanged' event so StreamingEngine has time to
+          // absorb the changes before the user tries to query it.
+          const event = shaka.Player.makeEvent_(
+              shaka.util.FakeEvent.EventName.TracksChanged);
+          await Promise.resolve();
+          preloadManager.dispatchEvent(event);
+        }
+      },
+      makeTextStreamsForClosedCaptions: (manifest) => {
+        return this.makeTextStreamsForClosedCaptions_(manifest);
+      },
+
+      // 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) => {
+        preloadManager.getRegionTimeline().addRegion(region);
+      },
+
+      onEvent: (event) => preloadManager.dispatchEvent(event),
+      onError: (error) => preloadManager.onError(error),
+      isLowLatencyMode: () => getConfig().streaming.lowLatencyMode,
+      isAutoLowLatencyMode: () => getConfig().streaming.autoLowLatencyMode,
+      enableLowLatencyMode: () => {
+        setConfig('streaming.lowLatencyMode', true);
+      },
+      updateDuration: () => {
+        if (this.streamingEngine_ && preloadManager.hasBeenAttached()) {
+          this.streamingEngine_.updateDuration();
+        }
+      },
+      newDrmInfo: (stream) => {
+        // We may need to create new sessions for any new init data.
+        const drmEngine = preloadManager.getDrmEngine();
+        const currentDrmInfo = drmEngine ? drmEngine.getDrmInfo() : null;
+        // DrmEngine.newInitData() requires mediaKeys to be available.
+        if (currentDrmInfo && drmEngine.getMediaKeys()) {
+          manifestFilterer.processDrmInfos(currentDrmInfo.keySystem, stream);
+        }
+      },
+      onManifestUpdated: () => {
+        const eventName = shaka.util.FakeEvent.EventName.ManifestUpdated;
+        const data = (new Map()).set('isLive', this.isLive());
+        preloadManager.dispatchEvent(shaka.Player.makeEvent_(eventName, data));
+
+        preloadManager.addQueuedOperation(false, () => {
+          if (this.adManager_) {
+            this.adManager_.onManifestUpdated(this.isLive());
+          }
+        });
+      },
+      getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+    };
+    const regionTimeline =
+        new shaka.media.RegionTimeline(() => this.seekRange());
+    regionTimeline.addEventListener('regionadd', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionAdded, region,
+          preloadManager);
+
+      preloadManager.addQueuedOperation(false, () => {
+        if (this.adManager_) {
+          this.adManager_.onDashTimedMetadata(region);
+        }
+      });
+    });
+    let qualityObserver = null;
+    if (config.streaming.observeQualityChanges) {
+      qualityObserver = new shaka.media.QualityObserver(
+          () => this.getBufferedInfo());
+
+      qualityObserver.addEventListener('qualitychange', (event) => {
+        /** @type {shaka.extern.MediaQualityInfo} */
+        const mediaQualityInfo = event['quality'];
+        /** @type {number} */
+        const position = event['position'];
+        this.onMediaQualityChange_(mediaQualityInfo, position);
+      });
+    }
+    let firstEvent = true;
+    const drmPlayerInterface = {
+      netEngine: this.networkingEngine_,
+      onError: (e) => preloadManager.onError(e),
+      onKeyStatus: (map) => {
+        preloadManager.addQueuedOperation(true, () => {
+          this.onKeyStatus_(map);
+        });
+      },
+      onExpirationUpdated: (id, expiration) => {
+        const event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.ExpirationUpdated);
+        preloadManager.dispatchEvent(event);
+        const parser = preloadManager.getParser();
+        if (parser && parser.onExpirationUpdated) {
+          parser.onExpirationUpdated(id, expiration);
+        }
+      },
+      onEvent: (e) => {
+        preloadManager.dispatchEvent(e);
+        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
+            firstEvent) {
+          firstEvent = false;
+          const now = Date.now() / 1000;
+          const delta = now - preloadManager.getStartTimeOfDRM();
+          const stats = this.stats_ || preloadManager.getStats();
+          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.lcevcDec_) {
+            this.lcevcDec_.hideCanvas();
+          }
+        }
+      },
+    };
+
+    // Sadly, as the network engine creation code must be replaceable by tests,
+    // it cannot be made and use the utilities defined in this function.
+    const networkingEngine = this.createNetworkingEngine(getPreloadManager);
+
+    /** @return {!shaka.media.DrmEngine} */
+    const createDrmEngine = () => {
+      return this.createDrmEngine(drmPlayerInterface);
+    };
+    /** @type {!shaka.media.PreloadManager.PlayerInterface} */
+    const playerInterface = {
+      config,
+      manifestPlayerInterface,
+      regionTimeline,
+      qualityObserver,
+      createDrmEngine,
+      manifestFilterer,
+      networkingEngine,
+      allowPrefetch,
+      allowMakeAbrManager,
+    };
+    preloadManager = new shaka.media.PreloadManager(
+        assetUri, mimeType, startTimeOfLoad, startTime, playerInterface);
+    return preloadManager;
+  }
+
   /**
    * Determines the mimeType of the given asset, if we are not told that inside
    * the loading process.
    *
+   * @param {string} assetUri
    * @return {!Promise.<?string>} mimeType
    * @private
    */
-  async guessMimeType_() {
-    goog.asserts.assert(this.assetUri_, 'should have a uri by now.');
-
+  async guessMimeType_(assetUri) {
     // 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);
+        assetUri, this.networkingEngine_, retryParams);
     if (mimeType == 'application/x-mpegurl' && shaka.util.Platform.isApple()) {
       mimeType = 'application/vnd.apple.mpegurl';
     }
@@ -1516,6 +2038,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           return true;
         }
 
+        // Native FairPlay HLS can be preferred on Apple platfforms.
+        if (Platform.isApple() &&
+            (this.config_.drm.servers['com.apple.fps'] ||
+            this.config_.drm.servers['com.apple.fps.1_0'])) {
+          return this.config_.streaming.useNativeHlsForFairPlay;
+        }
+
         // For Safari, we have an older flag which only applies to this one
         // browser:
         if (Platform.isApple()) {
@@ -1559,276 +2088,52 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // until they are both initialized before setting the initial value.
     const textDisplayerFactory = this.config_.textDisplayFactory;
     const textDisplayer = textDisplayerFactory();
+    if (textDisplayer.configure) {
+      textDisplayer.configure(this.config_.textDisplayer);
+    } else {
+      shaka.Deprecate.deprecateFeature(5,
+          'Text displayer w/ configure',
+          'Text displayer should have a "configure" method!');
+    }
     this.lastTextFactory_ = textDisplayerFactory;
 
     const mediaSourceEngine = this.createMediaSourceEngine(
         this.video_,
-        textDisplayer,
-        (metadata, offset, endTime) => {
-          this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
-        },
-        this.lcevcDec_);
-    mediaSourceEngine.configure(this.config_.mediaSource);
-    const {segmentRelativeVttTiming} = this.config_.manifest;
-    mediaSourceEngine.setSegmentRelativeVttTiming(segmentRelativeVttTiming);
-
-    // Wait for media source engine to finish opening. This promise should
-    // NEVER be rejected as per the media source engine implementation.
-    await mediaSourceEngine.open();
-
-    // Wait until it is ready to actually store the reference.
-    this.mediaSourceEngine_ = mediaSourceEngine;
-  }
-
-  /**
-   * Pick an initialize a manifest parser, then have it download and parse the
-   * manifest.
-   *
-   * @param {?string=} mimeType
-   * @return {!Promise}
-   * @private
-   */
-  async parseManifestInner_(mimeType) {
-    goog.asserts.assert(
-        this.assetUri_,
-        'should have a uri when making the parser.');
-    goog.asserts.assert(
-        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.cmsdManager_,
-        'Need CMSD manager to process response headers.');
-    goog.asserts.assert(
-        this.config_,
-        'Need player config when initializing the parser.');
-
-    // Store references to things we asserted so that we don't need to
-    // reassert them again later.
-    const networkingEngine = this.networkingEngine_;
-
-    this.makeStateChangeEvent_('manifest-parser');
-
-    // Create the parser that we will use to parse the manifest.
-    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 (this.video_ && this.video_.nodeName === 'AUDIO') {
-      manifestConfig.disableVideo = true;
-    }
-
-    this.parser_.configure(manifestConfig);
-
-    // 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.
-    this.regionTimeline_ =
-        new shaka.media.RegionTimeline(() => this.seekRange());
-    this.regionTimeline_.addEventListener('regionadd', (event) => {
-      /** @type {shaka.extern.TimelineRegionInfo} */
-      const region = event['region'];
-      this.onRegionEvent_(
-          shaka.util.FakeEvent.EventName.TimelineRegionAdded, region);
-
-      if (this.adManager_) {
-        this.adManager_.onDashTimedMetadata(region);
-      }
-    });
-
-    this.qualityObserver_ = null;
-    if (this.config_.streaming.observeQualityChanges) {
-      this.qualityObserver_ = new shaka.media.QualityObserver(
-          () => this.getBufferedInfo());
-
-      this.qualityObserver_.addEventListener('qualitychange', (event) => {
-        /** @type {shaka.extern.MediaQualityInfo} */
-        const mediaQualityInfo = event['quality'];
-        /** @type {number} */
-        const position = event['position'];
-        this.onMediaQualityChange_(mediaQualityInfo, position);
-      });
-    }
-
-    const playerInterface = {
-      networkingEngine: networkingEngine,
-      filter: (manifest) => this.filterManifest_(manifest),
-      makeTextStreamsForClosedCaptions: (manifest) => {
-        return this.makeTextStreamsForClosedCaptions_(manifest);
-      },
-
-      // 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);
-      },
-
-      onEvent: (event) => this.dispatchEvent(event),
-      onError: (error) => this.onError_(error),
-      isLowLatencyMode: () => this.isLowLatencyMode_(),
-      isAutoLowLatencyMode: () => this.isAutoLowLatencyMode_(),
-      enableLowLatencyMode: () => {
-        this.configure('streaming.lowLatencyMode', true);
-      },
-      updateDuration: () => {
-        if (this.streamingEngine_) {
-          this.streamingEngine_.updateDuration();
-        }
-      },
-      newDrmInfo: (stream) => {
-        // We may need to create new sessions for any new init data.
-        const currentDrmInfo =
-            this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
-        // DrmEngine.newInitData() requires mediaKeys to be available.
-        if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
-          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;
-
-    this.makeStateChangeEvent_('manifest');
-
-    this.manifest_ = await this.parser_.start(
-        this.assetUri_, playerInterface);
-
-    // 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);
-
-    // 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);
-    }
-
-    // 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);
-  }
-
-  /**
-   * Initializes the DRM engine.
-   *
-   * @return {!Promise}
-   * @private
-   */
-  async initializeDrmInner_() {
-    goog.asserts.assert(
-        this.networkingEngine_,
-        '|onInitializeDrm_| should never be called after |destroy|');
-    goog.asserts.assert(
-        this.config_,
-        '|onInitializeDrm_| should never be called after |destroy|');
-    goog.asserts.assert(
-        this.manifest_,
-        '|this.manifest_| should have been set in an earlier step.');
-    goog.asserts.assert(
-        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;
-
-    this.drmEngine_ = this.createDrmEngine({
-      netEngine: this.networkingEngine_,
-      onError: (e) => {
-        this.onError_(e);
-      },
-      onKeyStatus: (map) => {
-        this.onKeyStatus_(map);
-      },
-      onExpirationUpdated: (id, expiration) => {
-        this.onExpirationUpdated_(id, expiration);
-      },
-      onEvent: (e) => {
-        this.dispatchEvent(e);
-        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
-            firstEvent) {
-          firstEvent = false;
-          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.lcevcDec_) {
-            this.lcevcDec_.hideCanvas();
-          }
-        }
-      },
-    });
-
-    this.drmEngine_.configure(this.config_.drm);
-
-    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
-        this.manifest_.variants, this.config_.restrictions, this.maxHwRes_);
-    if (tracksChanged && this.streamingEngine_) {
-      this.onTracksChanged_();
-    }
-
-    const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
-        this.manifest_.variants);
-
-    await this.drmEngine_.initForPlayback(
-        playableVariants,
-        this.manifest_.offlineSessionIds);
+        textDisplayer,
+        (metadata, offset, endTime) => {
+          this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
+        },
+        this.lcevcDec_);
+    mediaSourceEngine.configure(this.config_.mediaSource);
+    const {segmentRelativeVttTiming} = this.config_.manifest;
+    mediaSourceEngine.setSegmentRelativeVttTiming(segmentRelativeVttTiming);
 
-    await this.drmEngine_.attach(this.video_);
+    // Wait for media source engine to finish opening. This promise should
+    // NEVER be rejected as per the media source engine implementation.
+    await mediaSourceEngine.open();
 
-    // 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_);
+    // Wait until it is ready to actually store the reference.
+    this.mediaSourceEngine_ = mediaSourceEngine;
   }
 
   /**
    * Starts loading the content described by the parsed manifest.
    *
    * @param {number} startTimeOfLoad
+   * @param {?shaka.extern.Variant} prefetchedVariant
+   * @param {!Map.<number, shaka.media.SegmentPrefetch>} segmentPrefetchById
    * @return {!Promise}
    * @private
    */
-  async loadInner_(startTimeOfLoad) {
+  async loadInner_(startTimeOfLoad, prefetchedVariant, segmentPrefetchById) {
     goog.asserts.assert(
         this.video_, 'We should have a media element by now.');
     goog.asserts.assert(
         this.manifest_, 'The manifest should already be parsed.');
     goog.asserts.assert(
         this.assetUri_, 'We should have an asset uri by now.');
+    goog.asserts.assert(
+        this.abrManager_, 'We should have an abr manager by now.');
 
     this.makeStateChangeEvent_('load');
 
@@ -1852,46 +2157,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // depending on the config.
     this.setupLcevc_(this.config_);
 
-    const abrFactory = this.config_.abrFactory;
-    if (!this.abrManager_ || this.abrManagerFactory_ != abrFactory) {
-      this.abrManagerFactory_ = abrFactory;
-      this.abrManager_ = abrFactory();
-      if (typeof this.abrManager_.setMediaElement != 'function') {
-        shaka.Deprecate.deprecateFeature(5,
-            'AbrManager w/o setMediaElement',
-            'Please use an AbrManager with setMediaElement function.');
-        this.abrManager_.setMediaElement = () => {};
-      }
-      if (typeof this.abrManager_.setCmsdManager != 'function') {
-        shaka.Deprecate.deprecateFeature(5,
-            'AbrManager w/o setCmsdManager',
-            'Please use an AbrManager with setCmsdManager function.');
-        this.abrManager_.setCmsdManager = () => {};
-      }
-      if (typeof this.abrManager_.trySuggestStreams != 'function') {
-        shaka.Deprecate.deprecateFeature(5,
-            'AbrManager w/o trySuggestStreams',
-            'Please use an AbrManager with trySuggestStreams function.');
-        this.abrManager_.trySuggestStreams = () => {};
-      }
-      this.abrManager_.configure(this.config_.abr);
-    }
-
-    // Copy preferred languages from the config again, in case the config was
-    // changed between construction and playback.
-    this.currentAdaptationSetCriteria_ =
-        new shaka.media.PreferenceBasedCriteria(
-            this.config_.preferredAudioLanguage,
-            this.config_.preferredVariantRole,
-            this.config_.preferredAudioChannelCount,
-            this.config_.preferredVideoHdrLevel,
-            this.config_.preferSpatialAudio,
-            this.config_.preferredVideoLayout,
-            this.config_.preferredAudioLabel,
-            this.config_.preferredVideoLabel,
-            this.config_.mediaSource.codecSwitchingStrategy,
-            this.config_.manifest.dash.enableAudioGroups);
-
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
     this.currentTextRole_ = this.config_.preferredTextRole;
     this.currentTextForced_ = this.config_.preferForcedSubs;
@@ -1906,14 +2171,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.abrManager_.setMediaElement(mediaElement);
     this.abrManager_.setCmsdManager(this.cmsdManager_);
 
-    // If the content is multi-codec and the browser can play more than one of
-    // them, choose codecs now before we initialize streaming.
-    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
-        this.manifest_,
-        this.config_.preferredVideoCodecs,
-        this.config_.preferredAudioCodecs,
-        this.config_.preferredDecodingAttributes);
-
     this.streamingEngine_ = this.createStreamingEngine();
     this.streamingEngine_.configure(this.config_.streaming);
 
@@ -1944,15 +2201,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // The event must be fired after we filter by restrictions but before the
     // active stream is picked to allow those listening for the "streaming"
     // event to make changes before streaming starts.
-    this.dispatchEvent(
-        this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
+    this.dispatchEvent(shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.Streaming));
 
     // Pick the initial streams to play.
     // Unless the user has already picked a variant, anyway, by calling
     // selectVariantTrack before this loading stage.
-    let initialVariant = null;
+    let initialVariant = prefetchedVariant;
     const activeVariant = this.streamingEngine_.getCurrentVariant();
-    if (!activeVariant) {
+    if (!activeVariant && !initialVariant) {
       initialVariant = this.chooseVariant_(/* initialSelection= */ true);
       goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
     }
@@ -1977,31 +2234,49 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
 
-    this.playhead_ = this.createPlayhead(this.startTime_);
-    this.playheadObservers_ =
-        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.
-    const rebufferThreshold = Math.max(
-        this.manifest_.minBufferTime, this.config_.streaming.rebufferingGoal);
-    this.startBufferManagement_(mediaElement, rebufferThreshold);
+    const setupPlayhead = (startTime) => {
+      this.playhead_ = this.createPlayhead(startTime);
+      this.playheadObservers_ =
+          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.
+      const rebufferThreshold = Math.max(
+          this.manifest_.minBufferTime,
+          this.config_.streaming.rebufferingGoal);
+      this.startBufferManagement_(mediaElement, rebufferThreshold);
+    };
+
+    if (!this.config_.streaming.startAtSegmentBoundary) {
+      setupPlayhead(this.startTime_);
+    }
 
     // Now we can switch to the initial variant.
     if (!activeVariant) {
       goog.asserts.assert(initialVariant,
           'Must have choosen an initial variant!');
 
-      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.
       if (this.config_.streaming.startAtSegmentBoundary) {
-        this.playhead_.setStartTime(await this.adjustStartTime_(
-            initialVariant, this.playhead_.getTime()));
+        const timeline = this.manifest_.presentationTimeline;
+        let initialTime = this.startTime_ || this.video_.currentTime;
+        const seekRangeStart = timeline.getSeekRangeStart();
+        const seekRangeEnd = timeline.getSeekRangeEnd();
+        if (initialTime < seekRangeStart) {
+          initialTime = seekRangeStart;
+        } else if (initialTime > seekRangeEnd) {
+          initialTime = seekRangeEnd;
+        }
+        const startTime = await this.adjustStartTime_(
+            initialVariant, initialTime);
+        setupPlayhead(startTime);
       }
+
+      this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
+          /* clearBuffer= */ false, /* safeMargin= */ 0);
     }
 
     this.playhead_.ready();
@@ -2033,7 +2308,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Start streaming content. This will start the flow of content down to
     // media source.
-    await this.streamingEngine_.start();
+    await this.streamingEngine_.start(segmentPrefetchById);
 
     if (this.config_.abr.enabled) {
       this.abrManager_.enable();
@@ -2061,8 +2336,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const isLive = this.isLive();
 
-    if (isLive && (this.config_.streaming.liveSync ||
-        this.manifest_.serviceDescription)) {
+    if ((isLive && (this.config_.streaming.liveSync ||
+        this.manifest_.serviceDescription ||
+        this.config_.streaming.liveSyncPanicMode)) ||
+        this.config_.streaming.vodDynamicPlaybackRate) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
     } else if (!isLive) {
@@ -2112,10 +2389,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.onError_(e);
       },
       onKeyStatus: (map) => {
-        this.onKeyStatus_(map);
+        // According to this.onKeyStatus_, we can't even use this information
+        // in src= mode, so this is just a no-op.
       },
       onExpirationUpdated: (id, expiration) => {
-        this.onExpirationUpdated_(id, expiration);
+        const event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.ExpirationUpdated);
+        this.dispatchEvent(event);
       },
       onEvent: (e) => {
         this.dispatchEvent(e);
@@ -2174,12 +2454,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         accessibilityPurpose: null,
         external: false,
         fastSwitching: false,
+        fullMimeTypes: new Set(),
       },
       bandwidth: 100,
       allowedByApplication: true,
       allowedByKeySystem: true,
       decodingInfos: [],
     };
+    variant.video.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        variant.video.mimeType, variant.video.codecs));
 
     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
@@ -2313,6 +2596,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       mediaElement.load();
     }
 
+    // In Safari using HLS won't load anything unless you call load()
+    // explicitly, no matter the value of the preload attribute.
+    // Note: this only happens when there are not autoplay.
+    if (mediaElement.preload != 'none' && !mediaElement.autoplay &&
+        shaka.util.MimeUtils.isHlsType(mimeType) &&
+        shaka.util.Platform.safariVersion()) {
+      mediaElement.load();
+    }
+
     // Set the load mode last so that we know that all our components are
     // initialized.
     this.loadMode_ = shaka.Player.LoadMode.SRC_EQUALS;
@@ -2320,8 +2612,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // 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));
+    this.dispatchEvent(shaka.Player.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
@@ -2393,7 +2685,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const isLive = this.isLive();
 
-    if (isLive && this.config_.streaming.liveSync) {
+    if ((isLive && (this.config_.streaming.liveSync ||
+        this.config_.streaming.liveSyncPanicMode)) ||
+        this.config_.streaming.vodDynamicPlaybackRate) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
     } else if (!isLive) {
@@ -2553,7 +2847,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('endTime', endTime)
         .set('metadataType', metadataType)
         .set('payload', payload);
-    this.dispatchEvent(this.makeEvent_(eventName, data));
+    this.dispatchEvent(shaka.Player.makeEvent_(eventName, data));
   }
 
   /**
@@ -2583,35 +2877,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     });
   }
 
-  /**
-   * Take a series of variants and ensure that they only contain one type of
-   * variant. The different options are:
-   *  1. Audio-Video
-   *  2. Audio-Only
-   *  3. Video-Only
-   *
-   * A manifest can only contain a single type because once we initialize media
-   * source to expect specific streams, it must always have content for those
-   * streams. If we were to start with audio+video and switch to an audio-only
-   * variant, media source would block waiting for video content.
-   *
-   * @param {shaka.extern.Manifest} manifest
-   * @private
-   */
-  static filterForAVVariants_(manifest) {
-    const isAVVariant = (variant) => {
-      // Audio-video variants may include both streams separately or may be
-      // single multiplexed streams with multiple codecs.
-      return (variant.video && variant.audio) ||
-             (variant.video && variant.video.codecs.includes(','));
-    };
-    if (manifest.variants.some(isAVVariant)) {
-      shaka.log.debug('Found variant with audio and video content, ' +
-          'so filtering out audio-only content.');
-      manifest.variants = manifest.variants.filter(isAVVariant);
-    }
-  }
-
   /**
    * Releases all of the mutexes of the player. Meant for use by the tests.
    * @export
@@ -2629,25 +2894,66 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @return {!shaka.media.DrmEngine}
    */
   createDrmEngine(playerInterface) {
-    const updateExpirationTime = this.config_.drm.updateExpirationTime;
-    return new shaka.media.DrmEngine(playerInterface, updateExpirationTime);
+    return new shaka.media.DrmEngine(playerInterface);
   }
 
   /**
    * Creates a new instance of NetworkingEngine.  This can be replaced by tests
    * to create fake instances instead.
    *
+   * @param {(function():?shaka.media.PreloadManager)=} getPreloadManager
    * @return {!shaka.net.NetworkingEngine}
    */
-  createNetworkingEngine() {
-    /** @type {function(number, number, boolean)} */
-    const onProgressUpdated_ = (deltaTimeMs, bytesDownloaded, allowSwitch) => {
+  createNetworkingEngine(getPreloadManager) {
+    if (!getPreloadManager) {
+      getPreloadManager = () => null;
+    }
+
+    const getAbrManager = () => {
+      if (getPreloadManager()) {
+        return getPreloadManager().getAbrManager();
+      } else {
+        return this.abrManager_;
+      }
+    };
+    const getParser = () => {
+      if (getPreloadManager()) {
+        return getPreloadManager().getParser();
+      } else {
+        return this.parser_;
+      }
+    };
+    const lateQueue = (fn) => {
+      if (getPreloadManager()) {
+        getPreloadManager().addQueuedOperation(true, fn);
+      } else {
+        fn();
+      }
+    };
+    const dispatchEvent = (event) => {
+      if (getPreloadManager()) {
+        getPreloadManager().dispatchEvent(event);
+      } else {
+        this.dispatchEvent(event);
+      }
+    };
+    const getStats = () => {
+      if (getPreloadManager()) {
+        return getPreloadManager().getStats();
+      } else {
+        return this.stats_;
+      }
+    };
+    /** @type {shaka.net.NetworkingEngine.onProgressUpdated} */
+    const onProgressUpdated_ = (deltaTimeMs,
+        bytesDownloaded, allowSwitch, request) => {
       // 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, allowSwitch);
+      const abrManager = getAbrManager();
+      if (abrManager) {
+        abrManager.segmentDownloaded(deltaTimeMs, bytesDownloaded,
+            allowSwitch, request);
       }
     };
     /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
@@ -2658,10 +2964,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           .set('headers', headers)
           .set('request', request)
           .set('requestType', requestType);
-      this.dispatchEvent(this.makeEvent_(name, data));
-      if (this.cmsdManager_) {
-        this.cmsdManager_.processHeaders(headers);
-      }
+      dispatchEvent(shaka.Player.makeEvent_(name, data));
+      lateQueue(() => {
+        if (this.cmsdManager_) {
+          this.cmsdManager_.processHeaders(headers);
+        }
+      });
     };
     /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
     const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
@@ -2672,23 +2980,35 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           .set('error', error)
           .set('httpResponseCode', httpResponseCode)
           .set('aborted', aborted);
-      this.dispatchEvent(this.makeEvent_(name, data));
+      dispatchEvent(shaka.Player.makeEvent_(name, data));
     };
     /** @type {shaka.net.NetworkingEngine.OnRequest} */
     const onRequest_ = (type, request, context) => {
-      this.cmcdManager_.applyData(type, request, context);
+      lateQueue(() => {
+        this.cmcdManager_.applyData(type, request, context);
+      });
     };
 
-
+    /** @type {shaka.net.NetworkingEngine.OnRetry} */
     const onRetry_ = (type, context, newUrl, oldUrl) => {
-      if (this.parser_ && this.parser_.banLocation) {
-        this.parser_.banLocation(oldUrl);
+      const parser = getParser();
+      if (parser && parser.banLocation) {
+        parser.banLocation(oldUrl);
+      }
+    };
+
+    /** @type {shaka.net.NetworkingEngine.OnResponse} */
+    const onResponse_ = (type, response, context) => {
+      const bytesDownloaded = response.data.byteLength;
+      const stats = getStats();
+      if (stats) {
+        stats.addBytesDownloaded(bytesDownloaded);
       }
     };
 
     return new shaka.net.NetworkingEngine(
         onProgressUpdated_, onHeadersReceived_, onDownloadFailed_, onRequest_,
-        onRetry_);
+        onRetry_, onResponse_);
   }
 
   /**
@@ -3015,11 +3335,33 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       delete config['streaming']['forceTransmux'];
     }
 
+    // Deprecate 'streaming.useNativeHlsOnSafari' configuration.
+    if (config['streaming'] && 'useNativeHlsOnSafari' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.useNativeHlsOnSafari configuration',
+          'Please Use streaming.useNativeHlsForFairPlay or ' +
+          'streaming.preferNativeHls instead.');
+    }
+
+    // Deprecate 'mediaSource.sourceBufferExtraFeatures' configuration.
+    if (config['mediaSource'] &&
+        'sourceBufferExtraFeatures' in config['mediaSource']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'mediaSource.sourceBufferExtraFeatures configuration',
+          'Please Use mediaSource.addExtraFeaturesToSourceBuffer() instead.');
+      const sourceBufferExtraFeatures =
+          config['mediaSource']['sourceBufferExtraFeatures'];
+      config['mediaSource']['addExtraFeaturesToSourceBuffer'] = () => {
+        return sourceBufferExtraFeatures;
+      };
+      delete config['mediaSource']['sourceBufferExtraFeatures'];
+    }
+
     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
     // rebufferingGoal and segmentPrefetchLimit and baseDelay are not
     // specified, set inaccurateManifestTolerance to 0 and rebufferingGoal
-    // to 0.01 and segmentPrefetchLimit to 2 and baseDelay to 100 by default
-    // for low latency streaming.
+    // to 0.01 and segmentPrefetchLimit to 2 and updateIntervalSeconds to
+    // 0.1 and baseDelay to 100 by default for low latency streaming.
     if (config['streaming'] && config['streaming']['lowLatencyMode']) {
       if (config['streaming']['inaccurateManifestTolerance'] == undefined) {
         config['streaming']['inaccurateManifestTolerance'] = 0;
@@ -3030,6 +3372,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       if (config['streaming']['segmentPrefetchLimit'] == undefined) {
         config['streaming']['segmentPrefetchLimit'] = 2;
       }
+      if (config['streaming']['updateIntervalSeconds'] == undefined) {
+        config['streaming']['updateIntervalSeconds'] = 0.1;
+      }
       if (config['streaming']['retryParameters'] == undefined) {
         config['streaming']['retryParameters'] = {};
       }
@@ -3067,6 +3412,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   applyConfig_() {
+    this.manifestFilterer_ = new shaka.media.ManifestFilterer(
+        this.config_, this.maxHwRes_, this.drmEngine_);
     if (this.parser_) {
       const manifestConfig =
           shaka.util.ObjectUtils.cloneObject(this.config_.manifest);
@@ -3083,9 +3430,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.streamingEngine_.configure(this.config_.streaming);
 
       // Need to apply the restrictions.
+      // this.filterManifestWithRestrictions_() may throw.
       try {
-        // this.filterManifestWithRestrictions_() may throw.
-        this.filterManifestWithRestrictions_(this.manifest_);
+        if (this.loadMode_ != shaka.Player.LoadMode.DESTROYED) {
+          if (this.manifestFilterer_.filterManifestWithRestrictions(
+              this.manifest_)) {
+            this.onTracksChanged_();
+          }
+        }
       } catch (error) {
         this.onError_(error);
       }
@@ -3118,6 +3470,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       const textDisplayerFactory = this.config_.textDisplayFactory;
       if (this.lastTextFactory_ != textDisplayerFactory) {
         const displayer = textDisplayerFactory();
+        if (displayer.configure) {
+          displayer.configure(this.config_.textDisplayer);
+        } else {
+          shaka.Deprecate.deprecateFeature(5,
+              'Text displayer w/ configure',
+              'Text displayer should have a "configure" method!');
+        }
         this.mediaSourceEngine_.setTextDisplayer(displayer);
         this.lastTextFactory_ = textDisplayerFactory;
 
@@ -3125,6 +3484,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           // Reload the text stream, so the cues will load again.
           this.streamingEngine_.reloadTextStream();
         }
+      } else {
+        const displayer = this.mediaSourceEngine_.getTextDisplayer();
+        if (displayer.configure) {
+          displayer.configure(this.config_.textDisplayer);
+        }
       }
     }
     if (this.abrManager_) {
@@ -3394,24 +3758,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
-  /**
-   * Return the value of lowLatencyMode configuration.
-   * @return {boolean}
-   * @private
-   */
-  isLowLatencyMode_() {
-    return this.config_.streaming.lowLatencyMode;
-  }
-
-  /**
-   * Return the value of autoLowLatencyMode configuration.
-   * @return {boolean}
-   * @private
-   */
-  isAutoLowLatencyMode_() {
-    return this.config_.streaming.autoLowLatencyMode;
-  }
-
   /**
    * Get the range of time (in seconds) that seeking is allowed. If the player
    * has not loaded content and the manifest is HLS, this will return a range
@@ -3620,12 +3966,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const currentTime = this.video_.currentTime;
         const seekRange = this.seekRange();
         const safeSeekOffset = this.config_.streaming.safeSeekOffset;
+
+        // Cancel trick play if we hit the beginning or end of the seekable
+        // (Sub-second accuracy not required here)
         if (rate > 0) {
-          if (currentTime >= seekRange.end) {
+          if (Math.floor(currentTime) >= Math.floor(seekRange.end)) {
             this.cancelTrickPlay();
           }
         } else {
-          if (currentTime <= (seekRange.start + safeSeekOffset)) {
+          if (Math.floor(currentTime) <=
+              Math.floor(seekRange.start + safeSeekOffset)) {
             this.cancelTrickPlay();
           }
         }
@@ -4465,19 +4815,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Get the current playhead position as a date. This should only be called
-   * when the player has loaded a live stream. If the player has not loaded a
-   * live stream, this will return <code>null</code>.
+   * Get the current playhead position as a date.
    *
    * @return {Date}
    * @export
    */
   getPlayheadTimeAsDate() {
-    if (!this.isLive()) {
-      shaka.log.warning('getPlayheadTimeAsDate is for live streams!');
-      return null;
-    }
-
     let presentationTime = 0;
     if (this.playhead_) {
       presentationTime = this.playhead_.getTime();
@@ -4514,22 +4857,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Get the presentation start time as a date. This should only be called when
-   * the player has loaded a live stream. If the player has not loaded a live
-   * stream, this will return <code>null</code>.
+   * Get the presentation start time as a date.
    *
    * @return {Date}
    * @export
    */
   getPresentationStartTimeAsDate() {
-    if (!this.isLive()) {
-      shaka.log.warning('getPresentationStartTimeAsDate is for live streams!');
-      return null;
-    }
-
     if (this.manifest_) {
       const timeline = this.manifest_.presentationTimeline;
-      const startTime = timeline.getPresentationStartTime();
+      const startTime = timeline.getInitialProgramDateTime() ||
+          timeline.getPresentationStartTime();
       goog.asserts.assert(startTime != null,
           'Presentation start time should not be null!');
       return new Date(/* ms= */ startTime * 1000);
@@ -4550,6 +4887,29 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Get the presentation segment availability duration. This should only be
+   * called when the player has loaded a live stream. If the player has not
+   * loaded a live stream, this will return <code>null</code>.
+   *
+   * @return {?number}
+   * @export
+   */
+  getSegmentAvailabilityDuration() {
+    if (!this.isLive()) {
+      shaka.log.warning('getSegmentAvailabilityDuration is for live streams!');
+      return null;
+    }
+
+    if (this.manifest_) {
+      const timeline = this.manifest_.presentationTimeline;
+      return timeline.getSegmentAvailabilityDuration();
+    } else {
+      shaka.log.warning('No way to get segment segment availability duration!');
+      return null;
+    }
+  }
+
   /**
    * Get information about what the player has buffered. If the player has not
    * loaded content or is currently loading content, the buffered content will
@@ -4804,6 +5164,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', codec || '')]),
     };
 
     const fullMimeType = shaka.util.MimeUtils.getFullType(
@@ -4960,6 +5322,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', '')]),
     };
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
@@ -5170,8 +5534,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /**
    * Set the maximum resolution that the platform's hardware can handle.
-   * This will be called automatically by <code>shaka.cast.CastReceiver</code>
-   * to enforce limitations of the Chromecast hardware.
    *
    * @param {number} width
    * @param {number} height
@@ -5274,8 +5636,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // TextDisplay factory must capture a reference to "this".
     config.textDisplayFactory = () => {
       if (this.videoContainer_) {
+        const latestConfig = this.getConfiguration();
         return new shaka.text.UITextDisplayer(
-            this.video_, this.videoContainer_);
+            this.video_, this.videoContainer_, latestConfig.textDisplayer);
       } else {
         // eslint-disable-next-line no-restricted-syntax
         if (HTMLMediaElement.prototype.addTextTrack) {
@@ -5390,6 +5753,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               accessibilityPurpose: null,
               external: false,
               fastSwitching: false,
+              fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+                  mimeType, '')]),
             };
             manifest.textStreams.push(textStream);
             closedCaptionsSet.add(id);
@@ -5399,82 +5764,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
-  /**
-   * Filters a manifest, removing unplayable streams/variants.
-   *
-   * @param {?shaka.extern.Manifest} manifest
-   * @private
-   */
-  async filterManifest_(manifest) {
-    await this.filterManifestWithStreamUtils_(manifest);
-    this.filterManifestWithRestrictions_(manifest);
-  }
-
-  /**
-   * Filters a manifest, removing unplayable streams/variants.
-   *
-   * @param {?shaka.extern.Manifest} manifest
-   * @private
-   */
-  async filterManifestWithStreamUtils_(manifest) {
-    goog.asserts.assert(manifest, 'Manifest should exist!');
-    await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest);
-    this.checkPlayableVariants_(manifest);
-  }
-
-
-  /**
-   * Apply the restrictions configuration to the manifest, and check if there's
-   * a variant that meets the restrictions.
-   *
-   * @param {?shaka.extern.Manifest} manifest
-   * @private
-   */
-  filterManifestWithRestrictions_(manifest) {
-    // Return if |destroy| is called.
-    if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
-      return;
-    }
-    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
-        manifest.variants, this.config_.restrictions, this.maxHwRes_);
-    if (tracksChanged && this.streamingEngine_) {
-      this.onTracksChanged_();
-    }
-
-    // We may need to create new sessions for any new init data.
-    const currentDrmInfo =
-        this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
-    // DrmEngine.newInitData() requires mediaKeys to be available.
-    if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
-      for (const variant of manifest.variants) {
-        this.processDrmInfos_(currentDrmInfo.keySystem, variant.video);
-        this.processDrmInfos_(currentDrmInfo.keySystem, variant.audio);
-      }
-    }
-    this.checkRestrictedVariants_(manifest);
-  }
-
-  /**
-   * @param {string} keySystem
-   * @param {?shaka.extern.Stream} stream
-   * @private
-   */
-  processDrmInfos_(keySystem, stream) {
-    if (!stream) {
-      return;
-    }
-
-    for (const drmInfo of stream.drmInfos) {
-      // Ignore any data for different key systems.
-      if (drmInfo.keySystem == keySystem) {
-        for (const initData of (drmInfo.initData || [])) {
-          this.drmEngine_.newInitData(
-              initData.initDataType, initData.initData);
-        }
-      }
-    }
-  }
-
   /**
    * @param {shaka.extern.Variant} initialVariant
    * @param {number} time
@@ -5553,7 +5842,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // buffering.
     const eventName = shaka.util.FakeEvent.EventName.Buffering;
     const data = (new Map()).set('buffering', isBuffering);
-    this.dispatchEvent(this.makeEvent_(eventName, data));
+    this.dispatchEvent(shaka.Player.makeEvent_(eventName, data));
   }
 
   /**
@@ -5586,7 +5875,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.playRateController_.set(newRate);
     }
 
-    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.RateChange);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.RateChange);
     this.dispatchEvent(event);
   }
 
@@ -5622,20 +5912,46 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (stateChanged) {
       const eventName = shaka.util.FakeEvent.EventName.StateChanged;
       const data = (new Map()).set('newstate', updateState);
-      this.dispatchEvent(this.makeEvent_(eventName, data));
+      this.dispatchEvent(shaka.Player.makeEvent_(eventName, data));
     }
   }
 
   /**
-   * Callback for liveSync
+   * Callback for liveSync and vodDynamicPlaybackRate
    *
    * @private
    */
   onTimeUpdate_() {
+    const playbackRate = this.video_.playbackRate;
+    const isLive = this.isLive();
+
+    if (this.config_.streaming.vodDynamicPlaybackRate && !isLive) {
+      const minPlaybackRate =
+        this.config_.streaming.vodDynamicPlaybackRateLowBufferRate;
+      const bufferFullness = this.getBufferFullness();
+      const bufferThreshold =
+        this.config_.streaming.vodDynamicPlaybackRateBufferRatio;
+
+      if (bufferFullness <= bufferThreshold) {
+        if (playbackRate != minPlaybackRate) {
+          shaka.log.debug('Buffer fullness ratio (' + bufferFullness + ') ' +
+            'is less than the vodDynamicPlaybackRateBufferRatio (' +
+            bufferThreshold + '). Updating playbackRate to ' + minPlaybackRate);
+          this.trickPlay(minPlaybackRate);
+        }
+      } else if (bufferFullness == 1) {
+        if (playbackRate !== this.playRateController_.getDefaultRate()) {
+          shaka.log.debug('Buffer is full. Cancel trick play.');
+          this.cancelTrickPlay();
+        }
+      }
+    }
+
     // If the live stream has reached its end, do not sync.
-    if (!this.isLive()) {
+    if (!isLive) {
       return;
     }
+
     const seekRange = this.seekRange();
     if (!Number.isFinite(seekRange.end)) {
       return;
@@ -5680,7 +5996,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
     }
 
-    const playbackRate = this.video_.playbackRate;
     const latency = seekRange.end - this.video_.currentTime;
     let offset = 0;
     // In src= mode, the seek range isn't updated frequently enough, so we need
@@ -5695,7 +6010,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
     }
 
-    if (liveSyncMaxLatency && liveSyncPlaybackRate &&
+    const panicMode = this.config_.streaming.liveSyncPanicMode;
+    const panicThreshold = this.config_.streaming.liveSyncPanicThreshold * 1000;
+    const timeSinceLastRebuffer =
+        Date.now() - this.bufferObserver_.getLastRebufferTime();
+    if (panicMode && !liveSyncMinPlaybackRate) {
+      liveSyncMinPlaybackRate = this.config_.streaming.liveSyncMinPlaybackRate;
+    }
+
+    if (panicMode && liveSyncMinPlaybackRate &&
+        timeSinceLastRebuffer <= panicThreshold) {
+      if (playbackRate != liveSyncMinPlaybackRate) {
+        shaka.log.debug('Time since last rebuffer (' +
+          timeSinceLastRebuffer + 's) ' +
+          'is less than the liveSyncPanicThreshold (' + panicThreshold +
+          's). Updating playbackRate to ' + liveSyncMinPlaybackRate);
+        this.trickPlay(liveSyncMinPlaybackRate);
+      }
+    } else if (liveSyncMaxLatency && liveSyncPlaybackRate &&
         (latency - offset) > liveSyncMaxLatency) {
       if (playbackRate != liveSyncPlaybackRate) {
         shaka.log.debug('Latency (' + latency + 's) ' +
@@ -5743,15 +6075,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (hasNewCompletionPercent) {
       let event;
       if (this.completionPercent_ == 0) {
-        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Started);
+        event = shaka.Player.makeEvent_(shaka.util.FakeEvent.EventName.Started);
       } else if (this.completionPercent_ == 25) {
-        event = this.makeEvent_(shaka.util.FakeEvent.EventName.FirstQuartile);
+        event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.FirstQuartile);
       } else if (this.completionPercent_ == 50) {
-        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Midpoint);
+        event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.Midpoint);
       } else if (this.completionPercent_ == 75) {
-        event = this.makeEvent_(shaka.util.FakeEvent.EventName.ThirdQuartile);
+        event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.ThirdQuartile);
       } else if (this.completionPercent_ == 100) {
-        event = this.makeEvent_(shaka.util.FakeEvent.EventName.Complete);
+        event = shaka.Player.makeEvent_(
+            shaka.util.FakeEvent.EventName.Complete);
       }
       if (event) {
         this.dispatchEvent(event);
@@ -5791,7 +6127,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   updateAbrManagerVariants_() {
     try {
       goog.asserts.assert(this.manifest_, 'Manifest should exist by now!');
-      this.checkRestrictedVariants_(this.manifest_);
+      this.manifestFilterer_.checkRestrictedVariants(this.manifest_);
     } catch (e) {
       this.onError_(e);
       return false;
@@ -6120,7 +6456,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('start', start)
         .set('end', end)
         .set('contentType', contentType);
-    this.dispatchEvent(this.makeEvent_(
+    this.dispatchEvent(shaka.Player.makeEvent_(
         shaka.util.FakeEvent.EventName.SegmentAppended, data));
   }
 
@@ -6170,8 +6506,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (this.lcevcDec_) {
       this.lcevcDec_.updateVariant(to, this.getManifestType());
     }
-    const event =
-        this.makeEvent_(shaka.util.FakeEvent.EventName.Adaptation, data);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.Adaptation, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -6182,7 +6518,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onTracksChanged_() {
     // Delay the 'trackschanged' event so StreamingEngine has time to absorb the
     // changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TracksChanged);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.TracksChanged);
     this.delayDispatchEvent_(event);
   }
 
@@ -6202,8 +6539,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.lcevcDec_.updateVariant(to, this.getManifestType());
     }
 
-    const event =
-        this.makeEvent_(shaka.util.FakeEvent.EventName.VariantChanged, data);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -6214,14 +6551,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onTextChanged_() {
     // Delay the 'textchanged' event so StreamingEngine time to absorb the
     // changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TextChanged);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.TextChanged);
     this.delayDispatchEvent_(event);
   }
 
   /** @private */
   onTextTrackVisibility_() {
-    const event =
-        this.makeEvent_(shaka.util.FakeEvent.EventName.TextTrackVisibility);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.TextTrackVisibility);
     this.delayDispatchEvent_(event);
   }
 
@@ -6233,7 +6571,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const data = (new Map()).set('newStatus', this.config_.abr.enabled);
-    this.delayDispatchEvent_(this.makeEvent_(
+    this.delayDispatchEvent_(shaka.Player.makeEvent_(
         shaka.util.FakeEvent.EventName.AbrStatusChanged, data));
   }
 
@@ -6367,7 +6705,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const eventName = shaka.util.FakeEvent.EventName.Error;
-    const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
+    const event = shaka.Player.makeEvent_(
+        eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
       error.handled = true;
@@ -6382,10 +6721,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    *
    * @param {!shaka.util.FakeEvent.EventName} eventName
    * @param {shaka.extern.TimelineRegionInfo} region
+   * @param {shaka.util.FakeEventTarget=} eventTarget
    *
    * @private
    */
-  onRegionEvent_(eventName, region) {
+  onRegionEvent_(eventName, region, eventTarget = this) {
     // Always make a copy to avoid exposing our internal data to the app.
     const clone = {
       schemeIdUri: region.schemeIdUri,
@@ -6394,10 +6734,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       endTime: region.endTime,
       id: region.id,
       eventElement: region.eventElement,
+      eventNode: region.eventNode,
     };
 
     const data = (new Map()).set('detail', clone);
-    this.dispatchEvent(this.makeEvent_(eventName, data));
+    eventTarget.dispatchEvent(shaka.Player.makeEvent_(eventName, data));
   }
 
   /**
@@ -6428,7 +6769,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('mediaQuality', clone)
         .set('position', position);
 
-    this.dispatchEvent(this.makeEvent_(
+    this.dispatchEvent(shaka.Player.makeEvent_(
         shaka.util.FakeEvent.EventName.MediaQualityChanged, data));
   }
 
@@ -6491,14 +6832,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   onKeyStatus_(keyStatusMap) {
-    if (!this.streamingEngine_) {
-      // We can't use this info to manage restrictions in src= mode, so ignore
-      // it.
-      return;
-    }
+    goog.asserts.assert(this.streamingEngine_, 'Cannot be called in src= mode');
 
-    const event =
-        this.makeEvent_(shaka.util.FakeEvent.EventName.KeyStatusChanged);
+    const event = shaka.Player.makeEvent_(
+        shaka.util.FakeEvent.EventName.KeyStatusChanged);
     this.dispatchEvent(event);
 
     const keyIds = Object.keys(keyStatusMap);
@@ -6520,7 +6857,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           'restrictions so we don\'t select those tracks.');
     }
 
-    const restrictedStatuses = shaka.Player.restrictedStatuses_;
+    const restrictedStatuses = shaka.media.ManifestFilterer.restrictedStatuses;
     let tracksChanged = false;
 
     goog.asserts.assert(this.drmEngine_, 'drmEngine should be non-null here.');
@@ -6569,22 +6906,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
-  /**
-   * Callback from DrmEngine
-   * @param {string} keyId
-   * @param {number} expiration
-   * @private
-   */
-  onExpirationUpdated_(keyId, expiration) {
-    if (this.parser_ && this.parser_.onExpirationUpdated) {
-      this.parser_.onExpirationUpdated(keyId, expiration);
-    }
-
-    const event =
-        this.makeEvent_(shaka.util.FakeEvent.EventName.ExpirationUpdated);
-    this.dispatchEvent(event);
-  }
-
   /**
    * @return {boolean} true if we should stream text right now.
    * @private
@@ -6628,93 +6949,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
-  /**
-   * Checks if the variants are all restricted, and throw an appropriate
-   * exception if so.
-   *
-   * @param {shaka.extern.Manifest} manifest
-   *
-   * @private
-   */
-  checkRestrictedVariants_(manifest) {
-    const restrictedStatuses = shaka.Player.restrictedStatuses_;
-    const keyStatusMap =
-        this.drmEngine_ ? this.drmEngine_.getKeyStatuses() : {};
-    const keyIds = Object.keys(keyStatusMap);
-    const isGlobalStatus = keyIds.length && keyIds[0] == '00';
-
-    let hasPlayable = false;
-    let hasAppRestrictions = false;
-
-    /** @type {!Set.<string>} */
-    const missingKeys = new Set();
-
-    /** @type {!Set.<string>} */
-    const badKeyStatuses = new Set();
-
-    for (const variant of manifest.variants) {
-      // TODO: Combine with onKeyStatus_.
-      const streams = [];
-      if (variant.audio) {
-        streams.push(variant.audio);
-      }
-      if (variant.video) {
-        streams.push(variant.video);
-      }
-
-      for (const stream of streams) {
-        if (stream.keyIds.size) {
-          for (const keyId of stream.keyIds) {
-            const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
-            if (!keyStatus) {
-              missingKeys.add(keyId);
-            } else if (restrictedStatuses.includes(keyStatus)) {
-              badKeyStatuses.add(keyStatus);
-            }
-          }
-        }  // if (stream.keyIds.size)
-      }
-
-      if (!variant.allowedByApplication) {
-        hasAppRestrictions = true;
-      } else if (variant.allowedByKeySystem) {
-        hasPlayable = true;
-      }
-    }
-
-    if (!hasPlayable) {
-      /** @type {shaka.extern.RestrictionInfo} */
-      const data = {
-        hasAppRestrictions,
-        missingKeys: Array.from(missingKeys),
-        restrictedKeyStatuses: Array.from(badKeyStatuses),
-      };
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET,
-          data);
-    }
-  }
-
-  /**
-   * Confirm some variants are playable. Otherwise, throw an exception.
-   * @param {!shaka.extern.Manifest} manifest
-   * @private
-   */
-  checkPlayableVariants_(manifest) {
-    const valid = manifest.variants.some(shaka.util.StreamUtils.isPlayable);
-
-    // If none of the variants are playable, throw
-    // CONTENT_UNSUPPORTED_BY_BROWSER.
-    if (!valid) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.CONTENT_UNSUPPORTED_BY_BROWSER);
-    }
-  }
-
   /**
    * Fire an event, but wait a little bit so that the immediate execution can
    * complete before the event is handled.
@@ -6947,25 +7181,13 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.7.12' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.8.0' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.
 shaka.Deprecate.init(shaka.Player.version);
 
 
-/**
- * These are the EME key statuses that represent restricted playback.
- * 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
- * of the usable keys.  'expired' status is being handled separately in
- * DrmEngine.
- *
- * @const {!Array.<string>}
- * @private
- */
-shaka.Player.restrictedStatuses_ = ['output-restricted', 'internal-error'];
-
-
 /** @private {!Object.<string, function():*>} */
 shaka.Player.supportPlugins_ = {};