shaka-player 4.9.13 → 4.10.1

package/lib/player.js

@@ -175,7 +175,6 @@ goog.requireType('shaka.media.PresentationTimeline');
  * @description Fired when the media quality changes at the playhead.
  * That may be caused by an adaptation change or a DASH period transition.
  * Separate events are emitted for audio and video contentTypes.
- * This is supported for only DASH streams at this time.
  * @property {string} type
  *   'mediaqualitychanged'
  * @property {shaka.extern.MediaQualityInfo} mediaQuality
@@ -185,6 +184,19 @@ goog.requireType('shaka.media.PresentationTimeline');
  * @exportDoc
  */
 
+/**
+ * @event shaka.Player.AudioTrackChangedEvent
+ * @description Fired when the audio track changes at the playhead.
+ * That may be caused by a user requesting to chang audio tracks.
+ * @property {string} type
+ *   'audiotrackchanged'
+ * @property {shaka.extern.MediaQualityInfo} mediaQuality
+ *   Information about media quality at the playhead position.
+ * @property {number} position
+ *   The playhead position.
+ * @exportDoc
+ */
+
 
 /**
  * @event shaka.Player.BufferingEvent
@@ -332,7 +344,7 @@ goog.requireType('shaka.media.PresentationTimeline');
  *   The time that describes the end of the range of the metadata to which
  *   the cue applies.
  * @property {string} metadataType
- *   Type of metadata. Eg: org.id3 or org.mp4ra
+ *   Type of metadata. Eg: 'org.id3' or 'com.apple.quicktime.HLS'
  * @property {shaka.extern.MetadataFrame} payload
  *   The metadata itself
  * @exportDoc
@@ -710,6 +722,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {?shaka.extern.PlayerConfiguration} */
     this.config_ = this.defaultConfig_();
 
+    /** @private {?number} */
+    this.currentTargetLatency_ = null;
+
+    /** @private {number} */
+    this.rebufferingCount_ = -1;
+
+    /** @private {?number} */
+    this.targetLatencyReached_ = null;
+
     /**
      * The TextDisplayerFactory that was last used to make a text displayer.
      * Stored so that we can tell if a new type of text displayer is desired.
@@ -779,6 +800,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {HTMLMediaElement} */
     this.preloadDueAdManagerVideo_ = null;
 
+    /** @private {boolean} */
+    this.preloadDueAdManagerVideoEnded_ = false;
+
     /** @private {shaka.util.Timer} */
     this.preloadDueAdManagerTimer_ = new shaka.util.Timer(async () => {
       if (this.preloadDueAdManager_) {
@@ -786,8 +810,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         await this.attach(
             this.preloadDueAdManagerVideo_, /* initializeMediaSource= */ true);
         await this.load(this.preloadDueAdManager_);
-        this.preloadDueAdManagerVideo_.play();
+        if (!this.preloadDueAdManagerVideoEnded_) {
+          this.preloadDueAdManagerVideo_.play();
+        } else {
+          this.preloadDueAdManagerVideo_.pause();
+        }
         this.preloadDueAdManager_ = null;
+        this.preloadDueAdManagerVideoEnded_ = false;
       }
     });
 
@@ -795,50 +824,43 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.adManager_ = shaka.Player.adManagerFactory_();
       this.adManager_.configure(this.config_.ads);
 
-      // Note: we don't use shaka.ads.AdManager.AD_STARTED to avoid add a
-      // optional module in the player.
+      // Note: we don't use shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED to
+      // avoid add a optional module in the player.
       this.adManagerEventManager_.listen(
-          this.adManager_, 'ad-started', async (e) => {
-            if (this.config_.ads.supportsMultipleMediaElements) {
-              return;
-            }
-            const event = /** @type {?google.ima.AdEvent} */
-              (e['originalEvent']);
-            if (!event) {
-              return;
-            }
-            const contentPauseRequested =
-                google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED;
-            if (event.type != contentPauseRequested) {
-              return;
-            }
+          this.adManager_, 'ad-content-pause-requested', async (e) => {
             this.preloadDueAdManagerTimer_.stop();
             if (!this.preloadDueAdManager_) {
               this.preloadDueAdManagerVideo_ = this.video_;
-              this.preloadDueAdManager_ =
-                await this.detachAndSavePreload(true);
+              this.preloadDueAdManagerVideoEnded_ = this.video_.ended;
+              const saveLivePosition = /** @type {boolean} */(
+                e['saveLivePosition']) || false;
+              this.preloadDueAdManager_ = await this.detachAndSavePreload(
+                  /* keepAdManager= */ true, saveLivePosition);
             }
           });
 
-      // Note: we don't use shaka.ads.AdManager.AD_STOPPED to avoid add a
-      // optional module in the player.
+      // Note: we don't use shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED to
+      // avoid add a optional module in the player.
       this.adManagerEventManager_.listen(
-          this.adManager_, 'ad-stopped', (e) => {
-            if (this.config_.ads.supportsMultipleMediaElements) {
-              return;
-            }
-            const event = /** @type {?google.ima.AdEvent} */
-              (e['originalEvent']);
-            if (!event) {
-              return;
-            }
-            const contentResumeRequested =
-                google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED;
-            if (event.type != contentResumeRequested) {
-              return;
+          this.adManager_, 'ad-content-resume-requested', (e) => {
+            const offset = /** @type {number} */(e['offset']) || 0;
+            if (this.preloadDueAdManager_) {
+              this.preloadDueAdManager_.setOffsetToStartTime(offset);
             }
             this.preloadDueAdManagerTimer_.tickAfter(0.1);
           });
+
+      // Note: we don't use shaka.ads.Utils.AD_CONTENT_ATTACH_REQUESTED to
+      // avoid add a optional module in the player.
+      this.adManagerEventManager_.listen(
+          this.adManager_, 'ad-content-attach-requested', async (e) => {
+            if (!this.video_ && this.preloadDueAdManagerVideo_) {
+              goog.asserts.assert(this.preloadDueAdManagerVideo_,
+                  'Must have video');
+              await this.attach(this.preloadDueAdManagerVideo_,
+                  /* initializeMediaSource= */ true);
+            }
+          });
     }
 
     // If the browser comes back online after being offline, then try to play
@@ -948,14 +970,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // A PreloadManager can only be used with the Player instance that created
     // it, so all PreloadManagers this Player has created are now useless.
     // Destroy any remaining managers now, to help prevent memory leaks.
-    const preloadManagerDestroys = [];
-    for (const preloadManager of this.createdPreloadManagers_) {
-      if (!preloadManager.isDestroyed()) {
-        preloadManagerDestroys.push(preloadManager.destroy());
-      }
-    }
-    this.createdPreloadManagers_ = [];
-    await Promise.all(preloadManagerDestroys);
+    await this.destroyAllPreloads();
 
     // Tear-down the event managers to ensure handlers stop firing.
     if (this.globalEventManager_) {
@@ -1462,6 +1477,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.stats_ = new shaka.util.Stats(); // Replace with a clean object.
       this.lastTextFactory_ = null;
 
+      this.targetLatencyReached_ = null;
+      this.currentTargetLatency_ = null;
+      this.rebufferingCount_ = -1;
+
       this.externalSrcEqualsThumbnailsStreams_ = [];
 
       this.completionPercent_ = NaN;
@@ -1473,7 +1492,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (initializeMediaSource && shaka.util.Platform.supportsMediaSource() &&
-        !this.mediaSourceEngine_) {
+        !this.mediaSourceEngine_ && this.video_) {
       await this.initializeMediaSourceEngineInner_();
     }
   }
@@ -1625,8 +1644,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // asset.
       const shouldUseSrcEquals = !preloadManager;
 
-      const startTimeOfLoad = preloadManager ?
-          preloadManager.getStartTimeOfLoad() : (Date.now() / 1000);
+      const startTimeOfLoad = Date.now() / 1000;
 
       // Stats are for a single playback/load session. Stats must be initialized
       // before we allow calls to |updateStateHistory|.
@@ -1662,6 +1680,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifestFilterer_ = preloadManager.getManifestFilterer();
         this.parserFactory_ = preloadManager.getParserFactory();
         this.parser_ = preloadManager.receiveParser();
+        if (this.parser_ && this.parser_.setMediaElement && this.video_) {
+          this.parser_.setMediaElement(this.video_);
+        }
         this.regionTimeline_ = preloadManager.receiveRegionTimeline();
         this.qualityObserver_ = preloadManager.getQualityObserver();
         this.manifest_ = preloadManager.getManifest();
@@ -1790,37 +1811,41 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * attached to something else.
    *
    * @param {boolean=} keepAdManager
+   * @param {boolean=} saveLivePosition
    * @return {!Promise.<?shaka.media.PreloadManager>}
    * @export
    */
-  async detachAndSavePreload(keepAdManager = false) {
-    const preloadManager = await this.savePreload_();
+  async detachAndSavePreload(keepAdManager = false, saveLivePosition = false) {
+    const preloadManager = await this.savePreload_(saveLivePosition);
     await this.detach(keepAdManager);
     return preloadManager;
   }
 
   /**
+   * @param {boolean=} saveLivePosition
    * @return {!Promise.<?shaka.media.PreloadManager>}
    * @private
    */
-  async savePreload_() {
+  async savePreload_(saveLivePosition = false) {
     let preloadManager = null;
     if (this.manifest_ && this.parser_ && this.parserFactory_ &&
         this.assetUri_) {
       let startTime = this.video_.currentTime;
-      if (this.isLive()) {
+      if (this.isLive() && !saveLivePosition) {
         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);
+      this.createdPreloadManagers_.push(preloadManager);
+      if (this.parser_ && this.parser_.setMediaElement) {
+        this.parser_.setMediaElement(/* mediaElement= */ null);
+      }
       preloadManager.attachManifest(
           this.manifest_, this.parser_, this.parserFactory_);
       preloadManager.attachAbrManager(
@@ -1878,6 +1903,21 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return preloadManager;
   }
 
+  /**
+   * Calls |destroy| on each PreloadManager object this player has created.
+   * @export
+   */
+  async destroyAllPreloads() {
+    const preloadManagerDestroys = [];
+    for (const preloadManager of this.createdPreloadManagers_) {
+      if (!preloadManager.isDestroyed()) {
+        preloadManagerDestroys.push(preloadManager.destroy());
+      }
+    }
+    this.createdPreloadManagers_ = [];
+    await Promise.all(preloadManagerDestroys);
+  }
+
   /**
    * @param {string} assetUri
    * @param {?number} startTime
@@ -1889,7 +1929,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   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);
     }
@@ -1915,23 +1954,34 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         disableVideo = true;
       }
     }
-    return this.makePreloadManager_(
-        assetUri, startTime, mimeType || null, startTimeOfLoad,
+    let preloadManagerPromise = this.makePreloadManager_(
+        assetUri, startTime, mimeType || null,
         /* allowPrefetch= */ !standardLoad, disableVideo, allowMakeAbrManager);
+    if (!standardLoad) {
+      // We only need to track the PreloadManager if it is not part of a
+      // standard load. If it is, the load() method will handle destroying it.
+      // Adding a standard load PreloadManager to the createdPreloadManagers_
+      // array runs the risk that the user will call destroyAllPreloads and
+      // destroy that PreloadManager mid-load.
+      preloadManagerPromise = preloadManagerPromise.then((preloadManager) => {
+        this.createdPreloadManagers_.push(preloadManager);
+        return preloadManager;
+      });
+    }
+    return preloadManagerPromise;
   }
 
   /**
    * @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,
+  async makePreloadManager_(assetUri, startTime, mimeType,
       allowPrefetch = true, disableVideo = false, allowMakeAbrManager = true) {
     goog.asserts.assert(this.networkingEngine_, 'Must have net engine');
     /** @type {?shaka.media.PreloadManager} */
@@ -2034,6 +2084,31 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         });
       },
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+      onMetadata: (type, startTime, endTime, values) => {
+        let metadataType = type;
+        if (type == 'com.apple.hls.interstitial') {
+          metadataType = 'com.apple.quicktime.HLS';
+          /** @type {shaka.extern.Interstitial} */
+          const interstitial = {
+            startTime,
+            endTime,
+            values,
+          };
+          if (this.adManager_) {
+            goog.asserts.assert(this.video_, 'Must have video');
+            this.adManager_.onInterstitialMetadata(
+                this, this.video_, interstitial);
+          }
+        }
+        for (const payload of values) {
+          preloadManager.addQueuedOperation(false, () => {
+            this.dispatchMetadataEvent_(
+                startTime, endTime, metadataType, payload);
+          });
+        }
+      },
+      disableStream: (stream) => this.disableStream(
+          stream, this.config_.streaming.maxDisabledTime),
     };
     const regionTimeline =
         new shaka.media.RegionTimeline(() => this.seekRange());
@@ -2062,6 +2137,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const position = event['position'];
         this.onMediaQualityChange_(mediaQualityInfo, position);
       });
+
+      qualityObserver.addEventListener('audiotrackchange', (event) => {
+        /** @type {shaka.extern.MediaQualityInfo} */
+        const mediaQualityInfo = event['quality'];
+        /** @type {number} */
+        const position = event['position'];
+        this.onMediaQualityChange_(mediaQualityInfo, position,
+            /* audioTrackChanged= */ true);
+      });
     }
     let firstEvent = true;
     const drmPlayerInterface = {
@@ -2126,8 +2210,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       allowMakeAbrManager,
     };
     preloadManager = new shaka.media.PreloadManager(
-        assetUri, mimeType, startTimeOfLoad, startTime, playerInterface);
-    this.createdPreloadManagers_.push(preloadManager);
+        assetUri, mimeType, startTime, playerInterface);
     return preloadManager;
   }
 
@@ -2200,11 +2283,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // 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 FairPlay HLS can be preferred on Apple platfforms.
         if (Platform.isApple() &&
             (this.config_.drm.servers['com.apple.fps'] ||
@@ -2212,11 +2290,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           return this.config_.streaming.useNativeHlsForFairPlay;
         }
 
-        // For Safari, we have an older flag which only applies to this one
-        // browser:
-        if (Platform.isApple()) {
-          return this.config_.streaming.useNativeHlsOnSafari;
-        }
+        // Native HLS can be preferred on any platform via this flag:
+        return this.config_.streaming.preferNativeHls;
       }
 
       // In all other cases, we prefer MediaSource.
@@ -2378,28 +2453,40 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Unless the user has already picked a variant, anyway, by calling
     // selectVariantTrack before this loading stage.
     let initialVariant = prefetchedVariant;
-    const activeVariant = this.streamingEngine_.getCurrentVariant();
-    if (!activeVariant && !initialVariant) {
-      initialVariant = this.chooseVariant_(/* initialSelection= */ true);
-      goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
-    }
-
-    // Lazy-load the stream, so we will have enough info to make the playhead.
-    const createSegmentIndexPromises = [];
-    const toLazyLoad = activeVariant || initialVariant;
-    for (const stream of [toLazyLoad.video, toLazyLoad.audio]) {
-      if (stream && !stream.segmentIndex) {
-        createSegmentIndexPromises.push(stream.createSegmentIndex());
+    let toLazyLoad;
+    let activeVariant;
+    do {
+      activeVariant = this.streamingEngine_.getCurrentVariant();
+      if (!activeVariant && !initialVariant) {
+        initialVariant = this.chooseVariant_(/* initialSelection= */ true);
+        goog.asserts.assert(initialVariant, 'Must choose an initial variant!');
+      }
+
+      // Lazy-load the stream, so we will have enough info to make the playhead.
+      const createSegmentIndexPromises = [];
+      toLazyLoad = activeVariant || initialVariant;
+      for (const stream of [toLazyLoad.video, toLazyLoad.audio]) {
+        if (stream && !stream.segmentIndex) {
+          createSegmentIndexPromises.push(stream.createSegmentIndex());
+        }
       }
-    }
-    if (createSegmentIndexPromises.length > 0) {
-      await Promise.all(createSegmentIndexPromises);
-    }
+      if (createSegmentIndexPromises.length > 0) {
+        // eslint-disable-next-line no-await-in-loop
+        await Promise.all(createSegmentIndexPromises);
+      }
+    } while (!toLazyLoad || toLazyLoad.disabledUntilTime != 0);
 
     if (this.parser_ && this.parser_.onInitialVariantChosen) {
       this.parser_.onInitialVariantChosen(toLazyLoad);
     }
 
+    if (this.manifest_.isLowLatency && !this.config_.streaming.lowLatencyMode) {
+      shaka.log.alwaysWarn('Low-latency live stream detected, but ' +
+          'low-latency streaming mode is not enabled in Shaka Player. ' +
+          'Set streaming.lowLatencyMode configuration to true, and see ' +
+          'https://bit.ly/3clctcj for details.');
+    }
+
     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
@@ -2508,9 +2595,10 @@ 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.liveSync.enabled) ||
         this.manifest_.serviceDescription ||
-        this.config_.streaming.liveSyncPanicMode)) ||
+        this.config_.streaming.liveSync.panicMode)) ||
         this.config_.streaming.vodDynamicPlaybackRate) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
@@ -2895,8 +2983,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const isLive = this.isLive();
 
-    if ((isLive && (this.config_.streaming.liveSync ||
-        this.config_.streaming.liveSyncPanicMode)) ||
+    if ((isLive && ((this.config_.streaming.liveSync &&
+        this.config_.streaming.liveSync.enabled) ||
+        this.config_.streaming.liveSync.panicMode)) ||
         this.config_.streaming.vodDynamicPlaybackRate) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
@@ -2985,6 +3074,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         return;
       }
 
+      /** @type {!Array.<shaka.extern.Interstitial>} */
+      const interstitials = [];
+
       for (const cue of track.activeCues) {
         this.dispatchMetadataEvent_(cue.startTime, cue.endTime,
             cue.type, cue.value);
@@ -2992,6 +3084,42 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         if (this.adManager_) {
           this.adManager_.onCueMetadataChange(cue.value);
         }
+        if (cue.type == 'com.apple.quicktime.HLS' && cue.startTime != null) {
+          let interstitial = interstitials.find((i) => {
+            return i.startTime == cue.startTime && i.endTime == cue.endTime;
+          });
+          if (!interstitial) {
+            interstitial = /** @type {shaka.extern.Interstitial} */ ({
+              startTime: cue.startTime,
+              endTime: cue.endTime,
+              values: [],
+            });
+            interstitials.push(interstitial);
+          }
+          interstitial.values.push(cue.value);
+        }
+      }
+      for (const interstitial of interstitials) {
+        const isValidInterstitial = interstitial.values.some((value) => {
+          return value.key == 'X-ASSET-URI' || value.key == 'X-ASSET-LIST';
+        });
+        if (!isValidInterstitial) {
+          continue;
+        }
+        if (this.adManager_) {
+          // It seems that CUE is natively omitted, by default we use CUE=ONCE
+          // to avoid repeating them.
+          interstitial.values.push({
+            key: 'CUE',
+            description: '',
+            data: 'ONCE',
+            mimeType: null,
+            pictureType: null,
+          });
+          goog.asserts.assert(this.video_, 'Must have video');
+          this.adManager_.onInterstitialMetadata(
+              this, this.video_, interstitial);
+        }
       }
     });
 
@@ -3215,6 +3343,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const stats = getStats();
         if (stats) {
           stats.addBytesDownloaded(bytesDownloaded);
+          if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST) {
+            stats.setManifestSize(bytesDownloaded);
+          }
         }
       }
     };
@@ -3526,6 +3657,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   configure(config, value) {
+    const Platform = shaka.util.Platform;
+
     goog.asserts.assert(this.config_, 'Config must not be null!');
     goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
         'String configs should have values!');
@@ -3563,6 +3696,121 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           'streaming.useNativeHlsOnSafari configuration',
           'Please Use streaming.useNativeHlsForFairPlay or ' +
           'streaming.preferNativeHls instead.');
+      config['streaming']['preferNativeHls'] =
+          config['streaming']['useNativeHlsOnSafari'] && Platform.isApple();
+      delete config['streaming']['useNativeHlsOnSafari'];
+    }
+
+    // Deprecate 'streaming.liveSync' boolean configuration.
+    if (config['streaming'] &&
+        typeof config['streaming']['liveSync'] == 'boolean') {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSync',
+          'Please Use streaming.liveSync.enabled instead.');
+      const liveSyncValue = config['streaming']['liveSync'];
+      config['streaming']['liveSync'] = {};
+      config['streaming']['liveSync']['enabled'] = liveSyncValue;
+    }
+
+    // map liveSyncMinLatency and liveSyncMaxLatency to liveSync.targetLatency
+    // if liveSync.targetLatency isn't set.
+    if (config['streaming'] && (!config['streaming']['liveSync'] ||
+      !('targetLatency' in config['streaming']['liveSync'])) &&
+      ('liveSyncMinLatency' in config['streaming'] ||
+       'liveSyncMaxLatency' in config['streaming'])) {
+      const min = config['streaming']['liveSyncMinLatency'] || 0;
+      const max = config['streaming']['liveSyncMaxLatency'] || 1;
+      const mid = Math.abs(max - min) / 2;
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['targetLatency'] = min + mid;
+      config['streaming']['liveSync']['targetLatencyTolerance'] = mid;
+    }
+    // Deprecate 'streaming.liveSyncMaxLatency' configuration.
+    if (config['streaming'] && 'liveSyncMaxLatency' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncMaxLatency',
+          'Please Use streaming.liveSync.targetLatency and ' +
+          'streaming.liveSync.targetLatencyTolerance instead. ' +
+          'Or, set the values in your DASH manifest');
+      delete config['streaming']['liveSyncMaxLatency'];
+    }
+    // Deprecate 'streaming.liveSyncMinLatency' configuration.
+    if (config['streaming'] && 'liveSyncMinLatency' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncMinLatency',
+          'Please Use streaming.liveSync.targetLatency and ' +
+          'streaming.liveSync.targetLatencyTolerance instead. ' +
+          'Or, set the values in your DASH manifest');
+      delete config['streaming']['liveSyncMinLatency'];
+    }
+
+    // Deprecate 'streaming.liveSyncTargetLatency' configuration.
+    if (config['streaming'] && 'liveSyncTargetLatency' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncTargetLatency',
+          'Please Use streaming.liveSync.targetLatency instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['targetLatency'] =
+          config['streaming']['liveSyncTargetLatency'];
+      delete config['streaming']['liveSyncTargetLatency'];
+    }
+
+    // Deprecate 'streaming.liveSyncTargetLatencyTolerance' configuration.
+    if (config['streaming'] &&
+      'liveSyncTargetLatencyTolerance' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncTargetLatencyTolerance',
+          'Please Use streaming.liveSync.targetLatencyTolerance instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['targetLatencyTolerance'] =
+          config['streaming']['liveSyncTargetLatencyTolerance'];
+      delete config['streaming']['liveSyncTargetLatencyTolerance'];
+    }
+
+    // Deprecate 'streaming.liveSyncPlaybackRate' configuration.
+    if (config['streaming'] && 'liveSyncPlaybackRate' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncPlaybackRate',
+          'Please Use streaming.liveSync.maxPlaybackRate instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['maxPlaybackRate'] =
+          config['streaming']['liveSyncPlaybackRate'];
+      delete config['streaming']['liveSyncPlaybackRate'];
+    }
+
+    // Deprecate 'streaming.liveSyncMinPlaybackRate' configuration.
+    if (config['streaming'] &&
+      'liveSyncMinPlaybackRate' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncMinPlaybackRate',
+          'Please Use streaming.liveSync.minPlaybackRate instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['minPlaybackRate'] =
+          config['streaming']['liveSyncMinPlaybackRate'];
+      delete config['streaming']['liveSyncMinPlaybackRate'];
+    }
+
+    // Deprecate 'streaming.liveSyncPanicMode' configuration.
+    if (config['streaming'] && 'liveSyncPanicMode' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncPanicMode',
+          'Please Use streaming.liveSync.panicMode instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['panicMode'] =
+          config['streaming']['liveSyncPanicMode'];
+      delete config['streaming']['liveSyncPanicMode'];
+    }
+
+    // Deprecate 'streaming.liveSyncPanicThreshold' configuration.
+    if (config['streaming'] &&
+      'liveSyncPanicThreshold' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.liveSyncPanicThreshold',
+          'Please Use streaming.liveSync.panicThreshold instead.');
+      config['streaming']['liveSync'] = config['streaming']['liveSync'] || {};
+      config['streaming']['liveSync']['panicThreshold'] =
+          config['streaming']['liveSyncPanicThreshold'];
+      delete config['streaming']['liveSyncPanicThreshold'];
     }
 
     // Deprecate 'mediaSource.sourceBufferExtraFeatures' configuration.
@@ -4064,6 +4312,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Indicates if the player has fully loaded the stream.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isFullyLoaded() {
+    return this.fullyLoaded_;
+  }
+
   /**
    * Get the key system currently used by EME. If EME is not being used, this
    * will return an empty string. If the player has not loaded content, this
@@ -4708,9 +4966,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {string=} role
    * @param {number=} channelsCount
    * @param {number=} safeMargin
+   * @param {string=} codec
    * @export
    */
-  selectAudioLanguage(language, role, channelsCount = 0, safeMargin = 0) {
+  selectAudioLanguage(language, role, channelsCount = 0, safeMargin = 0,
+      codec = '') {
     if (this.manifest_ && this.playhead_) {
       this.currentAdaptationSetCriteria_ =
           new shaka.media.PreferenceBasedCriteria(
@@ -4723,7 +4983,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               /* audioLabel= */ '',
               /* videoLabel= */ '',
               this.config_.mediaSource.codecSwitchingStrategy,
-              this.config_.manifest.dash.enableAudioGroups);
+              this.config_.manifest.dash.enableAudioGroups,
+              codec);
 
       const diff = (a, b) => {
         if (!a.video && !b.video) {
@@ -4743,6 +5004,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             this.currentAdaptationSetCriteria_.create(this.manifest_.variants);
       let bestVariant = null;
       for (const curVariant of set.values()) {
+        if (!shaka.util.StreamUtils.isPlayable(curVariant)) {
+          continue;
+        }
         if (!bestVariant ||
               diff(bestVariant, active) > diff(curVariant, active)) {
           bestVariant = curVariant;
@@ -5269,10 +5533,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.stats_.setLiveLatency(latency);
       }
 
-      if (this.manifest_ && this.manifest_.presentationTimeline) {
-        const maxSegmentDuration =
-            this.manifest_.presentationTimeline.getMaxSegmentDuration();
-        this.stats_.setMaxSegmentDuration(maxSegmentDuration);
+      if (this.manifest_) {
+        this.stats_.setManifestPeriodCount(this.manifest_.periodCount);
+        this.stats_.setManifestGapCount(this.manifest_.gapCount);
+        if (this.manifest_.presentationTimeline) {
+          const maxSegmentDuration =
+              this.manifest_.presentationTimeline.getMaxSegmentDuration();
+          this.stats_.setMaxSegmentDuration(maxSegmentDuration);
+        }
       }
 
       const estimate = this.abrManager_.getBandwidthEstimate();
@@ -6096,6 +6364,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.cmcdManager_.setBuffering(isBuffering);
       }
       this.updateStateHistory_();
+
+      const dynamicTargetLatency =
+          this.config_.streaming.liveSync.dynamicTargetLatency.enabled;
+      const maxAttempts =
+          this.config_.streaming.liveSync.dynamicTargetLatency.maxAttempts;
+
+
+      if (dynamicTargetLatency && isBuffering &&
+        this.rebufferingCount_ < maxAttempts) {
+        const maxLatency =
+            this.config_.streaming.liveSync.dynamicTargetLatency.maxLatency;
+
+        const targetLatencyTolerance =
+          this.config_.streaming.liveSync.targetLatencyTolerance;
+        const rebufferIncrement =
+          this.config_.streaming.liveSync.dynamicTargetLatency
+              .rebufferIncrement;
+        if (this.currentTargetLatency_) {
+          this.currentTargetLatency_ = Math.min(
+              this.currentTargetLatency_ +
+            ++this.rebufferingCount_ * rebufferIncrement,
+              maxLatency - targetLatencyTolerance);
+        }
+      }
     }
 
     // Surface the buffering event so that the app knows if/when we are
@@ -6222,52 +6514,78 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    let liveSyncMaxLatency;
-    let liveSyncPlaybackRate;
-    if (this.config_.streaming.liveSync) {
-      liveSyncMaxLatency = this.config_.streaming.liveSyncMaxLatency;
-      liveSyncPlaybackRate = this.config_.streaming.liveSyncPlaybackRate;
+    let targetLatency;
+    let maxLatency;
+    let maxPlaybackRate;
+    let minLatency;
+    let minPlaybackRate;
+    const targetLatencyTolerance =
+      this.config_.streaming.liveSync.targetLatencyTolerance;
+    const dynamicTargetLatency =
+      this.config_.streaming.liveSync.dynamicTargetLatency.enabled;
+    const stabilityThreshold =
+      this.config_.streaming.liveSync.dynamicTargetLatency.stabilityThreshold;
+
+    if (this.config_.streaming.liveSync &&
+      this.config_.streaming.liveSync.enabled) {
+      targetLatency = this.config_.streaming.liveSync.targetLatency;
+      maxLatency = targetLatency + targetLatencyTolerance;
+      minLatency = Math.max(0, targetLatency - targetLatencyTolerance);
+      maxPlaybackRate = this.config_.streaming.liveSync.maxPlaybackRate;
+      minPlaybackRate = this.config_.streaming.liveSync.minPlaybackRate;
     } else {
       // serviceDescription must override if it is defined in the MPD and
       // liveSync configuration is not set.
       if (this.manifest_ && this.manifest_.serviceDescription) {
-        liveSyncMaxLatency = this.config_.streaming.liveSyncMaxLatency;
+        targetLatency = this.manifest_.serviceDescription.targetLatency;
         if (this.manifest_.serviceDescription.targetLatency != null) {
-          liveSyncMaxLatency =
-              this.manifest_.serviceDescription.targetLatency +
-              this.config_.streaming.liveSyncTargetLatencyTolerance;
+          maxLatency = this.manifest_.serviceDescription.targetLatency +
+              targetLatencyTolerance;
         } else if (this.manifest_.serviceDescription.maxLatency != null) {
-          liveSyncMaxLatency = this.manifest_.serviceDescription.maxLatency;
+          maxLatency = this.manifest_.serviceDescription.maxLatency;
         }
-        liveSyncPlaybackRate =
-          this.manifest_.serviceDescription.maxPlaybackRate ||
-          this.config_.streaming.liveSyncPlaybackRate;
-      }
-    }
-
-    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.config_.streaming.liveSyncMinLatency;
         if (this.manifest_.serviceDescription.targetLatency != null) {
-          liveSyncMinLatency =
+          minLatency = Math.max(0,
               this.manifest_.serviceDescription.targetLatency -
-              this.config_.streaming.liveSyncTargetLatencyTolerance;
+              targetLatencyTolerance);
         } else if (this.manifest_.serviceDescription.minLatency != null) {
-          liveSyncMinLatency = this.manifest_.serviceDescription.minLatency;
+          minLatency = this.manifest_.serviceDescription.minLatency;
         }
-        liveSyncMinPlaybackRate =
+        maxPlaybackRate =
+          this.manifest_.serviceDescription.maxPlaybackRate ||
+          this.config_.streaming.liveSync.maxPlaybackRate;
+        minPlaybackRate =
           this.manifest_.serviceDescription.minPlaybackRate ||
-          this.config_.streaming.liveSyncMinPlaybackRate;
+          this.config_.streaming.liveSync.minPlaybackRate;
       }
     }
 
+    if (!this.currentTargetLatency_ && typeof targetLatency === 'number') {
+      this.currentTargetLatency_ = targetLatency;
+    }
+
+    const maxAttempts =
+        this.config_.streaming.liveSync.dynamicTargetLatency.maxAttempts;
+    if (dynamicTargetLatency && this.targetLatencyReached_ &&
+      this.currentTargetLatency_ !== null &&
+      typeof targetLatency === 'number' &&
+      this.rebufferingCount_ < maxAttempts &&
+      (Date.now() - this.targetLatencyReached_) > stabilityThreshold * 1000) {
+      const dynamicMinLatency =
+          this.config_.streaming.liveSync.dynamicTargetLatency.minLatency;
+      const latencyIncrement = (targetLatency - dynamicMinLatency) / 2;
+      this.currentTargetLatency_ = Math.max(
+          this.currentTargetLatency_ - latencyIncrement,
+          // current target latency should be within the tolerance of the min
+          // latency to not overshoot it
+          dynamicMinLatency + targetLatencyTolerance);
+      this.targetLatencyReached_ = Date.now();
+    }
+    if (dynamicTargetLatency && this.currentTargetLatency_ !== null) {
+      maxLatency = this.currentTargetLatency_ + targetLatencyTolerance;
+      minLatency = this.currentTargetLatency_ - targetLatencyTolerance;
+    }
+
     const latency = seekRange.end - this.video_.currentTime;
     let offset = 0;
     // In src= mode, the seek range isn't updated frequently enough, so we need
@@ -6278,45 +6596,49 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       const buffered = this.video_.buffered;
       if (buffered.length > 0) {
         const bufferedEnd = buffered.end(buffered.length - 1);
-        offset = Math.max(liveSyncPlaybackRate, bufferedEnd - seekRange.end);
+        offset = Math.max(maxPlaybackRate, bufferedEnd - seekRange.end);
       }
     }
 
-    const panicMode = this.config_.streaming.liveSyncPanicMode;
-    const panicThreshold = this.config_.streaming.liveSyncPanicThreshold * 1000;
+    const panicMode = this.config_.streaming.liveSync.panicMode;
+    const panicThreshold =
+        this.config_.streaming.liveSync.panicThreshold * 1000;
     const timeSinceLastRebuffer =
         Date.now() - this.bufferObserver_.getLastRebufferTime();
-    if (panicMode && !liveSyncMinPlaybackRate) {
-      liveSyncMinPlaybackRate = this.config_.streaming.liveSyncMinPlaybackRate;
+    if (panicMode && !minPlaybackRate) {
+      minPlaybackRate = this.config_.streaming.liveSync.minPlaybackRate;
     }
 
-    if (panicMode && liveSyncMinPlaybackRate &&
+    if (panicMode && minPlaybackRate &&
         timeSinceLastRebuffer <= panicThreshold) {
-      if (playbackRate != liveSyncMinPlaybackRate) {
+      if (playbackRate != minPlaybackRate) {
         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) ' +
-          'is greater than liveSyncMaxLatency (' + liveSyncMaxLatency + 's). ' +
-          'Updating playbackRate to ' + liveSyncPlaybackRate);
-        this.trickPlay(liveSyncPlaybackRate);
-      }
-    } 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);
-      }
+          'is less than the live sync panicThreshold (' + panicThreshold +
+          's). Updating playbackRate to ' + minPlaybackRate);
+        this.trickPlay(minPlaybackRate);
+      }
+    } else if (maxLatency && maxPlaybackRate &&
+      (latency - offset) > maxLatency) {
+      if (playbackRate != maxPlaybackRate) {
+        shaka.log.debug('Latency (' + latency + 's) is greater than ' +
+          'live sync maxLatency (' + maxLatency + 's). ' +
+          'Updating playbackRate to ' + maxPlaybackRate);
+        this.trickPlay(maxPlaybackRate);
+      }
+      this.targetLatencyReached_ = null;
+    } else if (minLatency && minPlaybackRate &&
+        (latency - offset) < minLatency) {
+      if (playbackRate != minPlaybackRate) {
+        shaka.log.debug('Latency (' + latency + 's) is smaller than ' +
+          'live sync minLatency (' + minLatency + 's). ' +
+          'Updating playbackRate to ' + minPlaybackRate);
+        this.trickPlay(minPlaybackRate);
+      }
+      this.targetLatencyReached_ = null;
     } else if (playbackRate !== this.playRateController_.getDefaultRate()) {
       this.cancelTrickPlay();
+      this.targetLatencyReached_ = Date.now();
     }
   }
 
@@ -6458,6 +6780,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return str;
     };
 
+    let shouldStopTimer = true;
     for (const variant of this.manifest_.variants) {
       if (variant.disabledUntilTime > 0 && variant.disabledUntilTime <= now) {
         variant.disabledUntilTime = 0;
@@ -6465,15 +6788,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
         shaka.log.v2('Re-enabled variant with ' + streamsAsString(variant));
       }
+      if (variant.disabledUntilTime > 0) {
+        shouldStopTimer = false;
+      }
     }
 
-    const shouldStopTimer = this.manifest_.variants.every((variant) => {
-      goog.asserts.assert(
-          variant.disabledUntilTime >= 0,
-          '|variant.disableTimeUntilTime| must always be >= 0');
-      return variant.disabledUntilTime === 0;
-    });
-
     if (shouldStopTimer) {
       this.checkVariantsTimer_.stop();
     }
@@ -6906,7 +7225,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const hasAltStream = this.manifest_.variants.some((variant) => {
       const altStream = variant[stream.type];
 
-      if (altStream && altStream.id !== stream.id) {
+      if (altStream && altStream.id !== stream.id &&
+          !variant.disabledUntilTime) {
         if (shaka.util.StreamUtils.isAudio(stream)) {
           return stream.language === altStream.language;
         }
@@ -6967,6 +7287,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
+    if (error.severity === shaka.util.Error.Severity.RECOVERABLE) {
+      this.stats_.addNonFatalError();
+    }
+
     let fireError = true;
     if (this.fullyLoaded_ && this.manifest_ && this.streamingEngine_ &&
         (error.code == shaka.util.Error.Code.VIDEO_ERROR ||
@@ -7032,10 +7356,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    *
    * @param {shaka.extern.MediaQualityInfo} mediaQuality
    * @param {number} position
+   * @param {boolean} audioTrackChanged This is to specify whether this should
+   * trigger a MediaQualityChangedEvent or an AudioTrackChangedEvent. Defaults
+   * to false to trigger MediaQualityChangedEvent.
    *
    * @private
    */
-  onMediaQualityChange_(mediaQuality, position) {
+  onMediaQualityChange_(mediaQuality, position, audioTrackChanged = false) {
     // Always make a copy to avoid exposing our internal data to the app.
     const clone = {
       bandwidth: mediaQuality.bandwidth,
@@ -7048,6 +7375,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       channelsCount: mediaQuality.channelsCount,
       pixelAspectRatio: mediaQuality.pixelAspectRatio,
       width: mediaQuality.width,
+      label: mediaQuality.label,
+      roles: mediaQuality.roles,
+      language: mediaQuality.language,
     };
 
     const data = new Map()
@@ -7055,7 +7385,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('position', position);
 
     this.dispatchEvent(shaka.Player.makeEvent_(
-        shaka.util.FakeEvent.EventName.MediaQualityChanged, data));
+        audioTrackChanged ?
+          shaka.util.FakeEvent.EventName.AudioTrackChanged :
+          shaka.util.FakeEvent.EventName.MediaQualityChanged,
+        data));
   }
 
   /**
@@ -7473,7 +7806,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.9.13' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.10.1' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.