shaka-player 4.0.2 → 4.1.1

package/lib/media/segment_index.js

@@ -94,6 +94,25 @@ shaka.media.SegmentIndex = class {
   }
 
 
+  /**
+   * Return the earliest reference, or null if empty.
+   * @return {shaka.media.SegmentReference}
+   */
+  earliestReference() {
+    return this.references[0] || null;
+  }
+
+
+  /**
+   * Drop the first N references.
+   * Used in early HLS synchronization, and does not count as eviction.
+   * @param {number} n
+   */
+  dropFirstReferences(n) {
+    this.references.splice(0, n);
+  }
+
+
   /**
    * Finds the position of the segment for the given time, in seconds, relative
    * to the start of the presentation.  Returns the position of the segment
@@ -166,7 +185,13 @@ shaka.media.SegmentIndex = class {
       for (const ref of this.references) {
         ref.startTime += offset;
         ref.endTime += offset;
-        ref.timestampOffset += offset;
+        ref.trueEndTime += offset;
+
+        for (const partial of ref.partialReferences) {
+          partial.startTime += offset;
+          partial.endTime += offset;
+          partial.trueEndTime += offset;
+        }
       }
     }
   }

package/lib/media/segment_reference.js

@@ -160,8 +160,9 @@ shaka.media.SegmentReference = class {
    *  If not provided, the duration should be automatically calculated based on
    *  the duration of the reference.
    * @param {?number=} syncTime
-   *  A time value, expressed in the same scale as the start and end time, which
-   *  is used to synchronize between streams.
+   *  A time value, expressed in seconds since 1970, which is used to
+   *  synchronize between streams.  Both produced and consumed by the HLS
+   *  parser.  Other components should not need this value.
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
@@ -221,7 +222,13 @@ shaka.media.SegmentReference = class {
     /** @type {?number} */
     this.tileDuration = tileDuration;
 
-    /** @type {?number} */
+    /**
+     * A time value, expressed in seconds since 1970, which is used to
+     * synchronize between streams.  Both produced and consumed by the HLS
+     * parser.  Other components should not need this value.
+     *
+     * @type {?number}
+     */
     this.syncTime = syncTime;
 
     /** @type {shaka.media.SegmentReference.Status} */

package/lib/media/stall_detector.js

@@ -9,6 +9,7 @@ goog.provide('shaka.media.StallDetector.Implementation');
 goog.provide('shaka.media.StallDetector.MediaElementImplementation');
 
 goog.require('shaka.media.TimeRangesUtils');
+goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IReleasable');
 
 /**
@@ -23,11 +24,14 @@ shaka.media.StallDetector = class {
   /**
    * @param {shaka.media.StallDetector.Implementation} implementation
    * @param {number} stallThresholdSeconds
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    */
-  constructor(implementation, stallThresholdSeconds) {
+  constructor(implementation, stallThresholdSeconds, onEvent) {
+    /** @private {?function(!Event)} */
+    this.onEvent_ = onEvent;
     /** @private {shaka.media.StallDetector.Implementation} */
     this.implementation_ = implementation;
-
     /** @private {boolean} */
     this.wasMakingProgress_ = implementation.shouldBeMakingProgress();
     /** @private {number} */
@@ -36,6 +40,8 @@ shaka.media.StallDetector = class {
     this.lastUpdateSeconds_ = implementation.getWallSeconds();
     /** @private {boolean} */
     this.didJump_ = false;
+    /** @private {number} */
+    this.stallsDetected_ = 0;
 
     /**
      * The amount of time in seconds that we must have the same value of
@@ -53,6 +59,7 @@ shaka.media.StallDetector = class {
   release() {
     // Drop external references to make things easier on the GC.
     this.implementation_ = null;
+    this.onEvent_ = null;
     this.onStall_ = () => {};
   }
 
@@ -66,6 +73,13 @@ shaka.media.StallDetector = class {
     this.onStall_ = doThis;
   }
 
+  /**
+   * Returns the number of playback stalls detected.
+   */
+  getStallsDetected() {
+    return this.stallsDetected_;
+  }
+
   /**
    * Have the detector update itself and fire the "on stall" callback if a stall
    * was detected.
@@ -100,6 +114,9 @@ shaka.media.StallDetector = class {
       // If the onStall_ method updated the current time, update our stored
       // value so we don't think that was an update.
       this.value_ = impl.getPresentationSeconds();
+      this.stallsDetected_++;
+      this.onEvent_(new shaka.util.FakeEvent(
+          shaka.util.FakeEvent.EventName.StallDetected));
     }
 
     return triggerCallback;

package/lib/media/streaming_engine.js

@@ -1215,6 +1215,13 @@ shaka.media.StreamingEngine = class {
     mediaState.performingUpdate = true;
 
     try {
+      if (reference.getStatus() ==
+          shaka.media.SegmentReference.Status.MISSING) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.RECOVERABLE,
+            shaka.util.Error.Category.NETWORK,
+            shaka.util.Error.Code.SEGMENT_MISSING);
+      }
       await this.initSourceBuffer_(mediaState, reference);
       this.destroyer_.ensureNotDestroyed();
       if (this.fatalError_) {
@@ -1602,7 +1609,7 @@ shaka.media.StreamingEngine = class {
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
-        reference.syncTime == null ? reference.startTime : reference.syncTime,
+        reference.startTime,
         reference.endTime,
         hasClosedCaptions,
         seeked);
@@ -1694,7 +1701,7 @@ shaka.media.StreamingEngine = class {
         };
 
         // Dispatch an event to notify the application about the emsg box.
-        const eventName = shaka.Player.EventName.Emsg;
+        const eventName = shaka.util.FakeEvent.EventName.Emsg;
         const data = (new Map()).set('detail', emsg);
         const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);

package/lib/offline/manifest_converter.js

@@ -302,6 +302,7 @@ shaka.offline.ManifestConverter = class {
     return {
       id: id,
       language: '',
+      disabledUntilTime: 0,
       primary: false,
       audio: null,
       video: null,

package/lib/player.js

@@ -385,6 +385,26 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.StallDetectedEvent
+ * @description Fired when a stall in playback is detected by the StallDetector.
+ *     Not all stalls are caused by gaps in the buffered ranges.
+ * @property {string} type
+ *   'stalldetected'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.GapJumpedEvent
+ * @description Fired when the GapJumpingController jumps over a gap in the
+ *     buffered ranges.
+ * @property {string} type
+ *   'gapjumped'
+ * @exportDoc
+ */
+
+
 /**
  * @summary The main player object for Shaka Player.
  *
@@ -652,7 +672,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       enterNode: (node, has, wants) => {
         this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.Player.EventName.OnStateChange,
+            /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
             /* data= */ (new Map()).set('state', node.name)));
 
         const action = actions.get(node);
@@ -683,7 +703,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onIdle: (node) => {
         this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.Player.EventName.OnStateIdle,
+            /* name= */ shaka.util.FakeEvent.EventName.OnStateIdle,
             /* data= */ (new Map()).set('state', node.name)));
       },
     };
@@ -694,6 +714,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.Player.createEmptyPayload_(),
         walkerImplementation);
 
+    /** @private {shaka.util.Timer} */
+    this.checkVariantsTimer_ =
+        new shaka.util.Timer(() => this.checkVariants_());
+
     // Even though |attach| will start in later interpreter cycles, it should be
     // the LAST thing we do in the constructor because conceptually it relies on
     // player having been initialized.
@@ -703,7 +727,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * @param {!shaka.Player.EventName} name
+   * @param {!shaka.util.FakeEvent.EventName} name
    * @param {Map.<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
@@ -1129,7 +1153,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // We dispatch the loading event when someone calls |load| because we want
     // to surface the user intent.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Loading));
+    this.dispatchEvent(this.makeEvent_(shaka.util.FakeEvent.EventName.Loading));
 
     // Right away we know what the asset uri and start-of-load time are. We will
     // fill-in the rest of the information later.
@@ -1193,7 +1217,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       events.onEnd = () => {
         resolve();
         // We dispatch the loaded event when the load promise is resolved
-        this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Loaded));
+        this.dispatchEvent(
+            this.makeEvent_(shaka.util.FakeEvent.EventName.Loaded));
       };
       events.onCancel = () => reject(this.createAbortLoadError_());
       events.onError = (e) => reject(e);
@@ -1398,7 +1423,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     await Promise.all(cleanupTasks);
 
     // Dispatch the unloading event.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Unloading));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
 
     // Remove everything that has to do with loading content from our payload
     // since we are releasing everything that depended on it.
@@ -1412,6 +1438,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.loadEventManager_.removeAll();
     }
 
+    // Stop the variant checker timer
+    this.checkVariantsTimer_.stop();
+
     // Some observers use some playback components, shutting down the observers
     // first ensures that they don't try to use the playback components
     // mid-destroy.
@@ -1699,7 +1728,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.regionTimeline_.addEventListener('regionadd', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionAdded, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionAdded, region);
 
       if (this.adManager_) {
         this.adManager_.onDashTimedMetadata(region);
@@ -1754,7 +1784,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
       // This event is fired after the manifest is parsed, but before any
       // filtering takes place.
-      const event = this.makeEvent_(shaka.Player.EventName.ManifestParsed);
+      const event =
+          this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
       this.dispatchEvent(event);
 
       // We require all manifests to have at least one variant.
@@ -1828,7 +1859,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onEvent: (e) => {
         this.dispatchEvent(e);
-        if (e.type == shaka.Player.EventName.DrmSessionUpdate && firstEvent) {
+        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
+            firstEvent) {
           firstEvent = false;
           const now = Date.now() / 1000;
           const delta = now - startTime;
@@ -1993,7 +2025,8 @@ 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.Player.EventName.Streaming));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
 
     // Pick the initial streams to play.
     // however, we would skip switch to initial variant
@@ -2121,7 +2154,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onEvent: (e) => {
         this.dispatchEvent(e);
-        if (e.type == shaka.Player.EventName.DrmSessionUpdate && firstEvent) {
+        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
+            firstEvent) {
           firstEvent = false;
           const now = Date.now() / 1000;
           const delta = now - startTime;
@@ -2154,6 +2188,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const variant = {
       id: 0,
       language: 'und',
+      disabledUntilTime: 0,
       primary: false,
       audio: null,
       video: {
@@ -2346,7 +2381,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.Player.EventName.Streaming));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
 
     // The "load" Promise is resolved when we have loaded the metadata.  If we
     // wait for the full data, that won't happen on Safari until the play button
@@ -2558,7 +2594,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   dispatchMetadataEvent_(startTime, endTime, metadataType, payload) {
     goog.asserts.assert(!endTime || startTime <= endTime,
         'Metadata start time should be less or equal to the end time!');
-    const eventName = shaka.Player.EventName.Metadata;
+    const eventName = shaka.util.FakeEvent.EventName.Metadata;
     const data = new Map()
         .set('startTime', startTime)
         .set('endTime', endTime)
@@ -2655,7 +2691,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
     const onHeadersReceived_ = (headers, request, requestType) => {
       // Release a 'downloadheadersreceived' event.
-      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const name = shaka.util.FakeEvent.EventName.DownloadHeadersReceived;
       const data = new Map()
           .set('headers', headers)
           .set('request', request)
@@ -2665,7 +2701,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
     const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
       // Release a 'downloadfailed' event.
-      const name = shaka.Player.EventName.DownloadFailed;
+      const name = shaka.util.FakeEvent.EventName.DownloadFailed;
       const data = new Map()
           .set('request', request)
           .set('error', error)
@@ -2693,7 +2729,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_,
         this.config_.streaming,
         startTime,
-        () => this.onSeek_());
+        () => this.onSeek_(),
+        (event) => this.dispatchEvent(event));
   }
 
   /**
@@ -2715,13 +2752,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     regionObserver.addEventListener('enter', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
     });
 
     regionObserver.addEventListener('exit', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
     });
 
     regionObserver.addEventListener('skip', (event) => {
@@ -2732,8 +2771,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // If we are seeking, we don't want to surface the enter/exit events since
       // they didn't play through them.
       if (!seeking) {
-        this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
-        this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
+        this.onRegionEvent_(
+            shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
+        this.onRegionEvent_(
+            shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
       }
     });
 
@@ -4089,8 +4130,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     for (const chaptersTrack of chaptersTracksWithLanguage) {
       if (chaptersTrack && chaptersTrack.cues) {
         for (const cue of chaptersTrack.cues) {
+          let id = cue.id;
+          if (!id || id == '') {
+            id = cue.startTime + '-' + cue.endTime + '-' + cue.text;
+          }
           /** @type {shaka.extern.Chapter} */
           const chapter = {
+            id: id,
             title: cue.text,
             startTime: cue.startTime,
             endTime: cue.endTime,
@@ -4355,6 +4401,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.stats_.setCompletionPercent(Math.round(100 * completionRatio));
     }
 
+    if (this.playhead_) {
+      this.stats_.setGapsJumped(this.playhead_.getGapsJumped());
+      this.stats_.setStallsDetected(this.playhead_.getStallsDetected());
+    }
+
     if (element.getVideoPlaybackQuality) {
       const info = element.getVideoPlaybackQuality();
 
@@ -5118,7 +5169,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Surface the buffering event so that the app knows if/when we are
     // buffering.
-    const eventName = shaka.Player.EventName.Buffering;
+    const eventName = shaka.util.FakeEvent.EventName.Buffering;
     const data = (new Map()).set('buffering', isBuffering);
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
@@ -5153,7 +5204,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.playRateController_.set(newRate);
     }
 
-    const event = this.makeEvent_(shaka.Player.EventName.RateChange);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.RateChange);
     this.dispatchEvent(event);
   }
 
@@ -5253,6 +5304,21 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Re-apply restrictions to the variants, to re-enable variants that were
+   * temporarily disabled due to network errors.
+   * If any variants are enabled this way, a new variant might be chosen for
+   * playback.
+   * @private
+   */
+  checkVariants_() {
+    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
+        this.manifest_.variants, this.config_.restrictions, this.maxHwRes_);
+    if (tracksChanged) {
+      this.chooseVariant_();
+    }
+  }
+
   /**
    * Choose a text stream from all possible text streams while taking into
    * account user preference.
@@ -5485,7 +5551,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    const event = this.makeEvent_(shaka.Player.EventName.Adaptation, data);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Adaptation, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5496,7 +5563,7 @@ 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.Player.EventName.TracksChanged);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TracksChanged);
     this.delayDispatchEvent_(event);
   }
 
@@ -5512,7 +5579,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, data);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5523,13 +5591,14 @@ 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.Player.EventName.TextChanged);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TextChanged);
     this.delayDispatchEvent_(event);
   }
 
   /** @private */
   onTextTrackVisibility_() {
-    const event = this.makeEvent_(shaka.Player.EventName.TextTrackVisibility);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.TextTrackVisibility);
     this.delayDispatchEvent_(event);
   }
 
@@ -5537,7 +5606,73 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onAbrStatusChanged_() {
     const data = (new Map()).set('newStatus', this.config_.abr.enabled);
     this.delayDispatchEvent_(this.makeEvent_(
-        shaka.Player.EventName.AbrStatusChanged, data));
+        shaka.util.FakeEvent.EventName.AbrStatusChanged, data));
+  }
+
+  /**
+   * Tries to recover from NETWORK HTTP_ERROR, temporary disabling the current
+   * problematic variant.
+   * @param {!shaka.util.Error} error
+   * @return {boolean}
+   * @private
+   */
+  tryToRecoverFromError_(error) {
+    if ((error.code != shaka.util.Error.Code.HTTP_ERROR &&
+      error.code != shaka.util.Error.Code.SEGMENT_MISSING) ||
+      error.category != shaka.util.Error.Category.NETWORK) {
+      return false;
+    }
+
+    let maxDisabledTime = this.config_.streaming.maxDisabledTime;
+    if (maxDisabledTime == 0) {
+      if (error.code == shaka.util.Error.Code.SEGMENT_MISSING) {
+        // Spec: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-6.3.3
+        // The client SHOULD NOT attempt to load Media Segments that have been
+        // marked with an EXT-X-GAP tag, or to load Partial Segments with a
+        // GAP=YES attribute. Instead, clients are encouraged to look for
+        // another Variant Stream of the same Rendition which does not have the
+        // same gap, and play that instead.
+        maxDisabledTime = 1;
+      } else {
+        return false;
+      }
+    }
+
+    if (error.code == shaka.util.Error.Code.HTTP_ERROR) {
+      shaka.log.debug('Recoverable NETWORK HTTP_ERROR, trying to recover...');
+    }
+
+    // Obtain the active variant and disable it from manifest variants
+    const activeVariantTrack = this.getVariantTracks().find((t) => t.active);
+    goog.asserts.assert(activeVariantTrack, 'Active variant should be found');
+    const manifest = this.manifest_;
+    for (const variant of manifest.variants) {
+      if (variant.id === activeVariantTrack.id) {
+        variant.disabledUntilTime = (Date.now() / 1000) + maxDisabledTime;
+      }
+    }
+
+    // Apply restrictions in order to disable variants
+    shaka.util.StreamUtils.applyRestrictions(
+        manifest.variants, this.config_.restrictions, this.maxHwRes_);
+
+    // Select for a new variant
+    const chosenVariant = this.chooseVariant_();
+    if (!chosenVariant) {
+      shaka.log.warning('Not enough variants to recover from error');
+      return false;
+    }
+
+    // Get the safeMargin to ensure a seamless playback
+    const {video} = this.getBufferedInfo();
+    const safeMargin =
+        video.reduce((size, {start, end}) => size + end - start, 0);
+
+    this.switchVariant_(chosenVariant, /* fromAdaptation= */ false,
+        /* clearBuffers= */ true, /* safeMargin= */ safeMargin);
+
+    this.checkVariantsTimer_.tickAfter(maxDisabledTime);
+    return true;
   }
 
   /**
@@ -5553,7 +5688,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    const eventName = shaka.Player.EventName.Error;
+
+    if (this.tryToRecoverFromError_(error)) {
+      error.handled = true;
+      return;
+    }
+
+    const eventName = shaka.util.FakeEvent.EventName.Error;
     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
@@ -5567,7 +5708,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * copy here because this is the transition point between the player and the
    * app.
    *
-   * @param {!shaka.Player.EventName} eventName
+   * @param {!shaka.util.FakeEvent.EventName} eventName
    * @param {shaka.extern.TimelineRegionInfo} region
    *
    * @private
@@ -5616,7 +5757,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('position', position);
 
     this.dispatchEvent(this.makeEvent_(
-        shaka.Player.EventName.MediaQualityChanged, data));
+        shaka.util.FakeEvent.EventName.MediaQualityChanged, data));
   }
 
   /**
@@ -5762,7 +5903,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.parser_.onExpirationUpdated(keyId, expiration);
     }
 
-    const event = this.makeEvent_(shaka.Player.EventName.ExpirationUpdated);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.ExpirationUpdated);
     this.dispatchEvent(event);
   }
 
@@ -6375,42 +6517,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 };
 
-/**
- * An internal enum that contains the string values of all of the player events.
- * This exists primarily to act as an implicit list of events, for tests.
- *
- * @enum {string}
- */
-shaka.Player.EventName = {
-  AbrStatusChanged: 'abrstatuschanged',
-  Adaptation: 'adaptation',
-  Buffering: 'buffering',
-  DownloadFailed: 'downloadfailed',
-  DownloadHeadersReceived: 'downloadheadersreceived',
-  DrmSessionUpdate: 'drmsessionupdate',
-  Emsg: 'emsg',
-  Error: 'error',
-  ExpirationUpdated: 'expirationupdated',
-  Loaded: 'loaded',
-  Loading: 'loading',
-  ManifestParsed: 'manifestparsed',
-  MediaQualityChanged: 'mediaqualitychanged',
-  Metadata: 'metadata',
-  OnStateChange: 'onstatechange',
-  OnStateIdle: 'onstateidle',
-  RateChange: 'ratechange',
-  SessionDataEvent: 'sessiondata',
-  Streaming: 'streaming',
-  TextChanged: 'textchanged',
-  TextTrackVisibility: 'texttrackvisibility',
-  TimelineRegionAdded: 'timelineregionadded',
-  TimelineRegionEnter: 'timelineregionenter',
-  TimelineRegionExit: 'timelineregionexit',
-  TracksChanged: 'trackschanged',
-  Unloading: 'unloading',
-  VariantChanged: 'variantchanged',
-};
-
 
 /**
  * In order to know what method of loading the player used for some content, we
@@ -6450,7 +6556,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.0.2-uncompiled';
+shaka.Player.version = 'v4.1.1-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.