shaka-player 4.3.9 → 4.4.0

package/lib/player.js

@@ -590,7 +590,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         new shaka.media.PreferenceBasedCriteria(
             this.config_.preferredAudioLanguage,
             this.config_.preferredVariantRole,
-            this.config_.preferredAudioChannelCount);
+            this.config_.preferredAudioChannelCount,
+            this.config_.preferredVideoHdrLevel);
 
     /** @private {string} */
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
@@ -617,6 +618,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       dependencyInjector(this);
     }
 
+
+    // Create the CMCD manager so client data can be attached to all requests
+    this.cmcdManager_ = this.createCmcd_();
+
     this.networkingEngine_ = this.createNetworkingEngine();
     this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
 
@@ -630,6 +635,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // If the browser comes back online after being offline, then try to play
     // again.
     this.globalEventManager_.listen(window, 'online', () => {
+      this.restoreDisabledVariants_();
       this.retryStreaming();
     });
 
@@ -799,13 +805,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const edge = shaka.util.Platform.isEdge() ||
           shaka.util.Platform.isLegacyEdge();
         if (edge) {
-          if (!config.streaming.forceTransmux) {
+          if (!config.mediaSource.forceTransmux) {
             // If forceTransmux is disabled for Microsoft Edge, LCEVC data
             // is stripped out in case of a MPEG-2 TS container.
             // Hence the warning for Microsoft Edge when playing content with
             // MPEG-2 TS container.
             shaka.log.alwaysWarn('LCEVC Warning: For MPEG-2 TS decoding '+
-            'the config.streaming.forceTransmux must be enabled.');
+            'the config.mediaSource.forceTransmux must be enabled.');
           }
         }
       }
@@ -1310,9 +1316,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // before we allow calls to |updateStateHistory|.
     this.stats_ = new shaka.util.Stats();
 
-    // Create the CMCD manager so client data can be attached to all requests
-    this.cmcdManager_ = this.createCmcd_();
-
     // Load's request is a little different, so we can't use our normal
     // listeners-to-promise method. It is the only request where we may skip the
     // request, so we need to set the on skip callback to reject with a specific
@@ -1870,12 +1873,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     const playerInterface = {
       networkingEngine: networkingEngine,
-      modifyManifestRequest: (request, manifestInfo) => {
-        this.cmcdManager_.applyManifestData(request, manifestInfo);
-      },
-      modifySegmentRequest: (request, segmentInfo) => {
-        this.cmcdManager_.applySegmentData(request, segmentInfo);
-      },
       filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
@@ -2113,7 +2110,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         new shaka.media.PreferenceBasedCriteria(
             this.config_.preferredAudioLanguage,
             this.config_.preferredVariantRole,
-            this.config_.preferredAudioChannelCount);
+            this.config_.preferredAudioChannelCount,
+            this.config_.preferredVideoHdrLevel,
+            this.config_.preferredAudioLabel);
 
     this.currentTextLanguage_ = this.config_.preferredTextLanguage;
     this.currentTextRole_ = this.config_.preferredTextRole;
@@ -2281,6 +2280,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
                         'arbitrary language initially');
     }
 
+    if (this.isLive() && (this.config_.streaming.liveSync ||
+        this.manifest_.serviceDescription)) {
+      const onTimeUpdate = () => this.onTimeUpdate_();
+      this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
+    }
+
     this.fullyLoaded_ = true;
 
     // Wait for the 'loadedmetadata' event to measure load() latency.
@@ -2379,6 +2384,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         drmInfos: [],  // Filled in by DrmEngine config.
         keyIds: new Set(),
         language: 'und',
+        originalLanguage: null,
         label: null,
         type: ContentType.VIDEO,
         primary: false,
@@ -2390,6 +2396,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         audioSamplingRate: null,
         spatialAudio: false,
         closedCaptions: null,
+        accessibilityPurpose: null,
         external: false,
       },
       bandwidth: 100,
@@ -2633,6 +2640,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.reject(abortedError);
       return Promise.resolve();  // Abort complete.
     }).chain(() => {
+      if (this.isLive() && this.config_.streaming.liveSync) {
+        const onTimeUpdate = () => this.onTimeUpdate_();
+        this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
+      }
+
       this.fullyLoaded_ = true;
     });
   }
@@ -2894,9 +2906,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           .set('aborted', aborted);
       this.dispatchEvent(this.makeEvent_(name, data));
     };
+    /** @type {shaka.net.NetworkingEngine.OnRequest} */
+    const onRequest_ = (type, request, context) => {
+      this.cmcdManager_.applyData(type, request, context);
+    };
 
     return new shaka.net.NetworkingEngine(
-        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_);
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_, onRequest_);
   }
 
   /**
@@ -3102,8 +3118,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.getBandwidthEstimate() : NaN,
       getBufferedInfo: () => this.getBufferedInfo(),
       getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
-      getVariantTracks: () => this.getVariantTracks(),
       getPlaybackRate: () => this.getPlaybackRate(),
+      getNetworkingEngine: () => this.getNetworkingEngine(),
+      getVariantTracks: () => this.getVariantTracks(),
       isLive: () => this.isLive(),
     };
 
@@ -3118,17 +3135,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   createStreamingEngine() {
     goog.asserts.assert(
-        this.abrManager_ && this.mediaSourceEngine_ &&
-        this.cmcdManager_ && this.manifest_,
+        this.abrManager_ && this.mediaSourceEngine_ && this.manifest_,
         'Must not be destroyed');
 
     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
     const playerInterface = {
       getPresentationTime: () => this.playhead_ ? this.playhead_.getTime() : 0,
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
-      modifySegmentRequest: (request, segmentInfo) => {
-        this.cmcdManager_.applySegmentData(request, segmentInfo);
-      },
       mediaSourceEngine: this.mediaSourceEngine_,
       netEngine: this.networkingEngine_,
       onError: (error) => this.onError_(error),
@@ -3149,6 +3162,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       onMetadata: (metadata, offset, endTime) => {
         this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
       },
+      disableStream: (stream, time) => this.disableStream(stream, time),
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -3196,15 +3210,26 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (config['streaming'] && 'forceTransmuxTS' in config['streaming']) {
       shaka.Deprecate.deprecateFeature(5,
           'streaming.forceTransmuxTS configuration',
-          'Please Use streaming.forceTransmux instead.');
-      config['streaming']['forceTransmux'] =
+          'Please Use mediaSource.forceTransmux instead.');
+      config['mediaSource']['mediaSource'] =
           config['streaming']['forceTransmuxTS'];
       delete config['streaming']['forceTransmuxTS'];
     }
 
+    // Deprecate 'streaming.forceTransmux' configuration.
+    if (config['streaming'] && 'forceTransmux' in config['streaming']) {
+      shaka.Deprecate.deprecateFeature(5,
+          'streaming.forceTransmux configuration',
+          'Please Use mediaSource.forceTransmux instead.');
+      config['mediaSource']['mediaSource'] =
+          config['streaming']['forceTransmux'];
+      delete config['streaming']['forceTransmux'];
+    }
+
     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
-    // rebufferingGoal are not specified, set inaccurateManifestTolerance to 0
-    // and rebufferingGoal to 0.01 by default for low latency streaming.
+    // rebufferingGoal and segmentPrefetchLimit are not specified, set
+    // inaccurateManifestTolerance to 0 and rebufferingGoal to 0.01 and
+    // segmentPrefetchLimit to 2 by default for low latency streaming.
     if (config['streaming'] && config['streaming']['lowLatencyMode']) {
       if (config['streaming']['inaccurateManifestTolerance'] == undefined) {
         config['streaming']['inaccurateManifestTolerance'] = 0;
@@ -3212,6 +3237,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       if (config['streaming']['rebufferingGoal'] == undefined) {
         config['streaming']['rebufferingGoal'] = 0.01;
       }
+      if (config['streaming']['segmentPrefetchLimit'] == undefined) {
+        config['streaming']['segmentPrefetchLimit'] = 2;
+      }
     }
     const ret = shaka.util.PlayerConfiguration.mergeConfigObjects(
         this.config_, config, this.defaultConfig_());
@@ -3311,6 +3339,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.config_.playRangeStart,
           this.config_.playRangeEnd);
     }
+    if (this.adManager_) {
+      this.adManager_.configure(this.config_.ads);
+    }
+    if (this.cmcdManager_) {
+      this.cmcdManager_.configure(this.config_.cmcd);
+    }
   }
 
   /**
@@ -3397,6 +3431,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.loadMode_;
   }
 
+  /**
+   * Get the current manifest type.
+   *
+   * @return {?string}
+   * @export
+   */
+  getManifestType() {
+    if (!this.manifest_) {
+      return null;
+    }
+    return this.manifest_.type;
+  }
+
   /**
    * Get the media element that the player is currently using to play loaded
    * content. If the player has not loaded content, this will return
@@ -3647,6 +3694,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.drmEngine_ ? this.drmEngine_.getExpiration() : Infinity;
   }
 
+  /**
+   * Returns the active sessions metadata
+   *
+   * @return {!Array.<shaka.extern.DrmSessionMetadata>}
+   * @export
+   */
+  getActiveSessionsMetadata() {
+    return this.drmEngine_ ? this.drmEngine_.getActiveSessionsMetadata() : [];
+  }
+
   /**
    * Gets a map of EME key ID to the current key status.
    *
@@ -4138,15 +4195,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {string} language
    * @param {string=} role
    * @param {number=} channelsCount
+   * @param {number=} safeMargin
    * @export
    */
-  selectAudioLanguage(language, role, channelsCount = 0) {
+  selectAudioLanguage(language, role, channelsCount = 0, safeMargin = 0) {
     const LanguageUtils = shaka.util.LanguageUtils;
 
     if (this.manifest_ && this.playhead_) {
       this.currentAdaptationSetCriteria_ =
           new shaka.media.PreferenceBasedCriteria(language, role || '',
-              channelsCount, /* label= */ '');
+              channelsCount, /* hdrLevel= */ '', /* label= */ '');
 
       const diff = (a, b) => {
         if (!a.video && !b.video) {
@@ -4173,7 +4231,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       if (bestVariant) {
         const track = shaka.util.StreamUtils.variantToTrack(bestVariant);
-        this.selectVariantTrack(track, /* clearBuffer= */ true);
+        this.selectVariantTrack(track, /* clearBuffer= */ true, safeMargin);
         return;
       }
 
@@ -4263,9 +4321,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * are expected to have the same variant.audio.
    *
    * @param {string} label
+   * @param {boolean=} clearBuffer Optional clear buffer or not when
+   *  switch to new variant
+   *  Defaults to true if not provided
+   * @param {number=} safeMargin Optional amount of buffer (in seconds) to
+   *   retain when clearing the buffer.
+   *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
    * @export
    */
-  selectVariantsByLabel(label) {
+  selectVariantsByLabel(label, clearBuffer = true, safeMargin = 0) {
     if (this.manifest_ && this.playhead_) {
       let firstVariantWithLabel = null;
       for (const variant of this.manifest_.variants) {
@@ -4287,9 +4351,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // label have the same language.
       this.currentAdaptationSetCriteria_ =
           new shaka.media.PreferenceBasedCriteria(
-              firstVariantWithLabel.language, '', 0, label);
+              firstVariantWithLabel.language, '', 0, '', label);
 
-      this.chooseVariantAndSwitch_();
+      this.chooseVariantAndSwitch_(clearBuffer, safeMargin);
     } else if (this.video_ && this.video_.audioTracks) {
       const audioTracks = Array.from(this.video_.audioTracks);
 
@@ -4813,6 +4877,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       drmInfos: [],
       keyIds: new Set(),
       language: language,
+      originalLanguage: language,
       label: label || null,
       type: ContentType.TEXT,
       primary: false,
@@ -4824,6 +4889,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       audioSamplingRate: null,
       spatialAudio: false,
       closedCaptions: null,
+      accessibilityPurpose: null,
       external: true,
     };
 
@@ -4964,6 +5030,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       drmInfos: [],
       keyIds: new Set(),
       language: 'und',
+      originalLanguage: null,
       label: null,
       type: ContentType.IMAGE,
       primary: false,
@@ -4976,6 +5043,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       spatialAudio: false,
       closedCaptions: null,
       tilesLayout: '1x1',
+      accessibilityPurpose: null,
       external: true,
     };
 
@@ -5373,6 +5441,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             // Add an empty segmentIndex, for the benefit of the period combiner
             // in our builtin DASH parser.
             const segmentIndex = new shaka.media.MetaSegmentIndex();
+            const language = video.closedCaptions.get(id);
             const textStream = {
               id: this.nextExternalStreamId_++,  // A globally unique ID.
               originalId: id, // The CC ID string, like 'CC1', 'CC3', etc.
@@ -5384,7 +5453,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               encrypted: false,
               drmInfos: [],
               keyIds: new Set(),
-              language: video.closedCaptions.get(id),
+              language,
+              originalLanguage: language,
               label: null,
               type: ContentType.TEXT,
               primary: false,
@@ -5396,6 +5466,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               audioSamplingRate: null,
               spatialAudio: false,
               closedCaptions: null,
+              accessibilityPurpose: null,
               external: false,
             };
             manifest.textStreams.push(textStream);
@@ -5650,6 +5721,71 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Callback for liveSync
+   *
+   * @private
+   */
+  onTimeUpdate_() {
+    // If the live stream has reached its end, do not sync.
+    if (!this.isLive()) {
+      return;
+    }
+    const seekRange = this.seekRange();
+    if (!Number.isFinite(seekRange.end)) {
+      return;
+    }
+    const currentTime = this.video_.currentTime;
+    if (currentTime < seekRange.start) {
+      // Bad stream?
+      return;
+    }
+
+    let liveSyncMaxLatency;
+    let liveSyncPlaybackRate;
+    if (this.config_.streaming.liveSync) {
+      liveSyncMaxLatency = this.config_.streaming.liveSyncMaxLatency;
+      liveSyncPlaybackRate = this.config_.streaming.liveSyncPlaybackRate;
+    } 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.manifest_.serviceDescription.maxLatency ||
+          this.config_.streaming.liveSyncMaxLatency;
+        liveSyncPlaybackRate =
+          this.manifest_.serviceDescription.maxPlaybackRate ||
+          this.config_.streaming.liveSyncPlaybackRate;
+      }
+    }
+
+    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
+    // to fudge the latency number with an offset.  The playback rate is used
+    // as an offset, since that is the amount we catch up 1 second of
+    // accelerated playback.
+    if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
+      const buffered = this.video_.buffered;
+      if (buffered.length > 0) {
+        const bufferedEnd = buffered.end(buffered.length - 1);
+        offset = Math.max(liveSyncPlaybackRate, bufferedEnd - seekRange.end);
+      }
+    }
+
+    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 (playbackRate !== 1 && playbackRate !== 0) {
+      this.cancelTrickPlay();
+    }
+  }
+
   /**
    * Callback from Playhead.
    *
@@ -5688,9 +5824,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return false;
     }
 
-    const playableVariants = this.manifest_.variants.filter((variant) => {
-      return shaka.util.StreamUtils.isPlayable(variant);
-    });
+    const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
+        this.manifest_.variants);
 
     // Update the abr manager with newly filtered variants.
     const adaptationSet = this.currentAdaptationSetCriteria_.create(
@@ -5717,17 +5852,55 @@ 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.
+   * Checks to re-enable variants that were temporarily disabled due to network
+   * errors. If any variants are enabled this way, a new variant may be chosen
+   * for playback.
    * @private
    */
   checkVariants_() {
-    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
-        this.manifest_.variants, this.config_.restrictions, this.maxHwRes_);
-    if (tracksChanged) {
-      this.chooseVariant_();
+    goog.asserts.assert(this.manifest_, 'Should have manifest!');
+
+    const now = Date.now() / 1000;
+    let hasVariantUpdate = false;
+
+    /** @type {function(shaka.extern.Variant):string} */
+    const streamsAsString = (variant) => {
+      let str = '';
+      if (variant.video) {
+        str += 'video:' + variant.video.id;
+      }
+      if (variant.audio) {
+        str += str ? '&' : '';
+        str += 'audio:' + variant.audio.id;
+      }
+      return str;
+    };
+
+    for (const variant of this.manifest_.variants) {
+      if (variant.disabledUntilTime > 0 && variant.disabledUntilTime <= now) {
+        variant.disabledUntilTime = 0;
+        hasVariantUpdate = true;
+
+        shaka.log.v2('Re-enabled variant with ' + streamsAsString(variant));
+      }
+    }
+
+    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();
+    }
+
+    if (hasVariantUpdate) {
+      // Reconsider re-enabled variant for ABR switching.
+      this.chooseVariantAndSwitch_(
+          /* clearBuffer= */ true, /* safeMargin= */ undefined,
+          /* force= */ false, /* fromAdaptation= */ false);
     }
   }
 
@@ -5754,9 +5927,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * Called after a config change, a key status event, or an explicit language
    * change.
    *
+   * @param {boolean=} clearBuffer Optional clear buffer or not when
+   *  switch to new variant
+   *  Defaults to true if not provided
+   * @param {number=} safeMargin Optional amount of buffer (in seconds) to
+   *   retain when clearing the buffer.
+   *   Defaults to 0 if not provided. Ignored if clearBuffer is false.
    * @private
    */
-  chooseVariantAndSwitch_() {
+  chooseVariantAndSwitch_(clearBuffer = true, safeMargin = 0, force = false,
+      fromAdaptation = true) {
     goog.asserts.assert(this.config_, 'Must not be destroyed');
 
     // Because we're running this after a config change (manual language
@@ -5764,8 +5944,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // here.
     const chosenVariant = this.chooseVariant_();
     if (chosenVariant) {
-      this.switchVariant_(chosenVariant, /* fromAdaptation= */ true,
-          /* clearBuffers= */ true, /* safeMargin= */ 0);
+      this.switchVariant_(chosenVariant, fromAdaptation,
+          clearBuffer, safeMargin, force);
     }
   }
 
@@ -5774,9 +5954,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {boolean} fromAdaptation
    * @param {boolean} clearBuffer
    * @param {number} safeMargin
+   * @param {boolean=} force
    * @private
    */
-  switchVariant_(variant, fromAdaptation, clearBuffer, safeMargin) {
+  switchVariant_(variant, fromAdaptation, clearBuffer, safeMargin,
+      force = false) {
     const currentVariant = this.streamingEngine_.getCurrentVariant();
     if (variant == currentVariant) {
       shaka.log.debug('Variant already selected.');
@@ -5793,7 +5975,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Add entries to the history.
     this.addVariantToSwitchHistory_(variant, fromAdaptation);
     this.streamingEngine_.switchVariant(
-        variant, clearBuffer, safeMargin, /* force= */ undefined,
+        variant, clearBuffer, safeMargin, force,
         /* adaptation= */ fromAdaptation);
     let oldTrack = null;
     if (currentVariant) {
@@ -6059,85 +6241,108 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /** @private */
   onAbrStatusChanged_() {
+    // Restore disabled variants if abr get disabled
+    if (!this.config_.abr.enabled) {
+      this.restoreDisabledVariants_();
+    }
+
     const data = (new Map()).set('newStatus', this.config_.abr.enabled);
     this.delayDispatchEvent_(this.makeEvent_(
         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}
+   * @param {boolean} updateAbrManager
    * @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;
-    }
+  restoreDisabledVariants_(updateAbrManager=true) {
     if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE) {
-      return false;
+      return;
     }
     goog.asserts.assert(this.manifest_, 'Should have manifest!');
 
+    shaka.log.v2('Restoring all disabled streams...');
+
+    this.checkVariantsTimer_.stop();
+
+    for (const variant of this.manifest_.variants) {
+      variant.disabledUntilTime = 0;
+    }
+
+    if (updateAbrManager) {
+      this.updateAbrManagerVariants_();
+    }
+  }
+
+  /**
+   * Temporarily disable all variants containing |stream|
+   * @param {shaka.extern.Stream} stream
+   * @param {number} disableTime
+   * @return {boolean}
+   */
+  disableStream(stream, disableTime) {
+    if (!this.config_.abr.enabled ||
+        this.loadMode_ === shaka.Player.LoadMode.DESTROYED) {
+      return false;
+    }
+
     if (!navigator.onLine) {
-      // Don't restrict variants if we're completely offline, or else we end up
+      // Don't disable variants if we're completely offline, or else we end up
       // rapidly restricting all of them.
       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;
+    // It only makes sense to disable a stream if we have an alternative else we
+    // end up disabling all variants.
+    const hasAltStream = this.manifest_.variants.some((variant) => {
+      const altStream = variant[stream.type];
+
+      if (altStream && altStream.id !== stream.id) {
+        if (shaka.util.StreamUtils.isAudio(stream)) {
+          return stream.language === altStream.language;
+        }
+        return true;
       }
-    }
+      return false;
+    });
 
-    if (error.code == shaka.util.Error.Code.HTTP_ERROR) {
-      shaka.log.debug('Recoverable NETWORK HTTP_ERROR, trying to recover...');
-    }
+    if (hasAltStream) {
+      let didDisableStream = false;
 
-    // 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;
+      for (const variant of this.manifest_.variants) {
+        const candidate = variant[stream.type];
+
+        if (candidate && candidate.id === stream.id) {
+          variant.disabledUntilTime = (Date.now() / 1000) + disableTime;
+          didDisableStream = true;
+
+          shaka.log.v2(
+              'Disabled stream ' + stream.type + ':' + stream.id +
+              ' for ' + disableTime + ' seconds...');
+        }
       }
-    }
 
-    // Apply restrictions in order to disable variants
-    shaka.util.StreamUtils.applyRestrictions(
-        manifest.variants, this.config_.restrictions, this.maxHwRes_);
+      goog.asserts.assert(didDisableStream, 'Must have disabled stream');
 
-    // Select for a new variant
-    const chosenVariant = this.chooseVariant_();
-    if (!chosenVariant) {
-      shaka.log.warning('Not enough variants to recover from error');
-      return false;
-    }
+      this.checkVariantsTimer_.tickEvery(1);
 
-    // Get the safeMargin to ensure a seamless playback
-    const {video} = this.getBufferedInfo();
-    const safeMargin =
-        video.reduce((size, {start, end}) => size + end - start, 0);
+      // 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);
+      // Update abr manager variants and switch to recover playback
+      this.chooseVariantAndSwitch_(
+          /* clearBuffer= */ true, /* safeMargin= */ safeMargin,
+          /* force= */ true, /* fromAdaptation= */ false);
+      return true;
+    }
 
-    this.checkVariantsTimer_.tickAfter(maxDisabledTime);
-    return true;
+    shaka.log.warning(
+        'No alternate stream found for active ' + stream.type + ' stream. ' +
+        'Will ignore request to disable stream...');
+
+    return false;
   }
 
   /**
@@ -6153,10 +6358,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-
-    if (this.tryToRecoverFromError_(error)) {
-      error.handled = true;
-      return;
+    // Restore disabled variant if the player experienced a critical error.
+    if (error.severity === shaka.util.Error.Severity.CRITICAL) {
+      this.restoreDisabledVariants_(/* updateAbrManager= */ false);
     }
 
     const eventName = shaka.util.FakeEvent.EventName.Error;
@@ -7020,7 +7224,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.3.9-uncompiled';
+shaka.Player.version = 'v4.4.0-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.