shaka-player 4.9.35 → 4.9.36

package/lib/media/drm_engine.js

@@ -1004,7 +1004,17 @@ shaka.media.DrmEngine = class {
 
     // If we have configured preferredKeySystems, choose a preferred keySystem
     // if available.
-    for (const preferredKeySystem of this.config_.preferredKeySystems) {
+    let preferredKeySystems = this.config_.preferredKeySystems;
+    if (!preferredKeySystems.length) {
+      // If there is no preference set and we only have one license server, we
+      // use this as preference. This is used to override manifests on those
+      // that have the embedded license and the browser supports multiple DRMs.
+      const servers = shaka.util.MapUtils.asMap(this.config_.servers);
+      if (servers.size == 1) {
+        preferredKeySystems = Array.from(servers.keys());
+      }
+    }
+    for (const preferredKeySystem of preferredKeySystems) {
       for (const variant of variants) {
         const decodingInfo = variant.decodingInfos.find((decodingInfo) => {
           return decodingInfo.supported &&
@@ -1028,8 +1038,15 @@ shaka.media.DrmEngine = class {
           if (!decodingInfo.supported || !decodingInfo.keySystemAccess) {
             continue;
           }
-          const drmInfos =
-              drmInfosByKeySystem.get(decodingInfo.keySystemAccess.keySystem);
+          const originalKeySystem = decodingInfo.keySystemAccess.keySystem;
+          if (preferredKeySystems.includes(originalKeySystem)) {
+            continue;
+          }
+          let drmInfos = drmInfosByKeySystem.get(originalKeySystem);
+          if (!drmInfos && this.config_.keySystemsMapping[originalKeySystem]) {
+            drmInfos = drmInfosByKeySystem.get(
+                this.config_.keySystemsMapping[originalKeySystem]);
+          }
           for (const info of drmInfos) {
             if (!!info.licenseServerUri == shouldHaveLicenseServer) {
               return decodingInfo.keySystemAccess;
@@ -1800,7 +1817,18 @@ shaka.media.DrmEngine = class {
      */
     const processMediaKeySystemAccess = async (keySystem, access) => {
       try {
-        await access.createMediaKeys();
+        // Workaround: Our automated test lab runs Windows browsers under a
+        // headless service.  In this environment, Firefox's ClearKey CDM seems
+        // to crash when we create the CDM here.
+        if (goog.DEBUG &&  // not a production build
+            shaka.util.Platform.isWindows() &&  // on Windows
+            shaka.util.Platform.isFirefox()) {  // with Firefox
+          // Reject this, since it crashes our tests.
+          throw new Error('Suppressing Firefox Windows ClearKey in testing!');
+        } else {
+          // Otherwise, create the CDM.
+          await access.createMediaKeys();
+        }
       } catch (error) {
         // In some cases, we can get a successful access object but fail to
         // create a MediaKeys instance.  When this happens, don't update the
@@ -1947,17 +1975,47 @@ shaka.media.DrmEngine = class {
       support.set(keySystem, null);
     }
 
+    const checkKeySystem = (keySystem) => {
+      // Our Polyfill will reject anything apart com.apple.fps key systems.
+      // It seems the Safari modern EME API will allow to request a
+      // MediaKeySystemAccess for the ClearKey CDM, create and update a key
+      // session but playback will never start
+      // Safari bug: https://bugs.webkit.org/show_bug.cgi?id=231006
+      if (shaka.util.DrmUtils.isClearKeySystem(keySystem) &&
+          shaka.util.Platform.isSafari()) {
+        return false;
+      }
+      // FairPlay is a proprietary DRM from Apple and will never work on
+      // Windows.
+      if (shaka.util.DrmUtils.isFairPlayKeySystem(keySystem) &&
+          shaka.util.Platform.isWindows()) {
+        return false;
+      }
+      // PlayReady is a proprietary DRM from Microsoft and will never work on
+      // Apple platforms
+      if (shaka.util.DrmUtils.isPlayReadyKeySystem(keySystem) &&
+          (shaka.util.Platform.isMac() || shaka.util.Platform.isApple())) {
+        return false;
+      }
+      // Mozilla has no intention of supporting PlayReady according to
+      // comments posted on Bugzilla.
+      if (shaka.util.DrmUtils.isPlayReadyKeySystem(keySystem) &&
+          shaka.util.Platform.isFirefox()) {
+        return false;
+      }
+      // We are sure that WisePlay is not supported on Windows or macOS.
+      if (shaka.util.DrmUtils.isWisePlayKeySystem(keySystem) &&
+          (shaka.util.Platform.isWindows() || shaka.util.Platform.isMac())) {
+        return false;
+      }
+      return true;
+    };
+
     // Test each key system and encryption scheme.
     const tests = [];
     for (const encryptionScheme of testEncryptionSchemes) {
       for (const keySystem of testKeySystems) {
-        // Our Polyfill will reject anything apart com.apple.fps key systems.
-        // It seems the Safari modern EME API will allow to request a
-        // MediaKeySystemAccess for the ClearKey CDM, create and update a key
-        // session but playback will never start
-        // Safari bug: https://bugs.webkit.org/show_bug.cgi?id=231006
-        if (keySystem === 'org.w3.clearkey' &&
-            shaka.util.Platform.isSafari()) {
+        if (!checkKeySystem(keySystem)) {
           continue;
         }
         tests.push(testSystemEme(keySystem, encryptionScheme, '', ''));
@@ -1967,6 +2025,9 @@ shaka.media.DrmEngine = class {
 
     for (const keySystem of testKeySystems) {
       for (const robustness of (testRobustness[keySystem] || [])) {
+        if (!checkKeySystem(keySystem)) {
+          continue;
+        }
         tests.push(testSystemEme(keySystem, null, robustness, ''));
         tests.push(testSystemEme(keySystem, null, '', robustness));
         tests.push(testSystemMcap(keySystem, null, robustness, ''));

package/lib/media/gap_jumping_controller.js

@@ -53,6 +53,9 @@ shaka.media.GapJumpingController = class {
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
+    /** @private {boolean} */
+    this.started_ = false;
+
     /** @private {boolean} */
     this.seekingEventReceived_ = false;
 
@@ -90,7 +93,7 @@ shaka.media.GapJumpingController = class {
      */
     this.gapJumpTimer_ = new shaka.util.Timer(() => {
       this.onPollGapJump_();
-    }).tickEvery(this.config_.gapJumpTimerTime);
+    });
   }
 
 
@@ -134,16 +137,22 @@ shaka.media.GapJumpingController = class {
    * @param {number} startTime
    */
   onStarted(startTime) {
+    this.started_ = true;
     if (this.video_.seeking && !this.seekingEventReceived_) {
       this.seekingEventReceived_ = true;
       this.startTime_ = startTime;
     }
+    if (this.gapJumpTimer_) {
+      this.gapJumpTimer_.tickEvery(this.config_.gapJumpTimerTime);
+    }
+    this.onPollGapJump_();
   }
 
   /** Called when a seek has started. */
   onSeeking() {
     this.seekingEventReceived_ = true;
     this.hadSegmentAppended_ = false;
+    this.onPollGapJump_();
   }
 
 
@@ -167,6 +176,10 @@ shaka.media.GapJumpingController = class {
     if (this.video_.readyState == 0) {
       return;
     }
+    // Don't gap jump before playback started
+    if (!this.started_) {
+      return;
+    }
     // Do not gap jump if seeking has begun, but the seeking event has not
     // yet fired for this particular seek.
     if (this.video_.seeking) {

package/lib/media/media_source_engine.js

@@ -543,6 +543,11 @@ shaka.media.MediaSourceEngine = class {
             stream, contentType),
         'Type negotiation should happen before MediaSourceEngine.init!');
 
+    if (contentType == ContentType.AUDIO && codecs) {
+      codecs = shaka.util.StreamUtils.getCorrectAudioCodecs(
+          codecs, stream.mimeType);
+    }
+
     let mimeType = shaka.util.MimeUtils.getFullType(
         stream.mimeType, codecs);
     if (contentType == ContentType.TEXT) {
@@ -1157,7 +1162,7 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       await this.textEngine_.remove(startTime, endTime);
-    } else {
+    } else if (endTime > startTime) {
       await this.enqueueOperation_(
           contentType,
           () => this.remove_(contentType, startTime, endTime),
@@ -1309,20 +1314,24 @@ shaka.media.MediaSourceEngine = class {
             null));
       }
     }
-    operations.push(this.enqueueOperation_(
-        contentType,
-        () => this.setAppendWindow_(
-            contentType, appendWindowStart, appendWindowEnd),
-        null));
-    if (this.needSplitMuxedContent_) {
+    if (appendWindowStart != 0 || appendWindowEnd != Infinity) {
       operations.push(this.enqueueOperation_(
-          ContentType.AUDIO,
+          contentType,
           () => this.setAppendWindow_(
-              ContentType.AUDIO, appendWindowStart, appendWindowEnd),
+              contentType, appendWindowStart, appendWindowEnd),
           null));
+      if (this.needSplitMuxedContent_) {
+        operations.push(this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.setAppendWindow_(
+                ContentType.AUDIO, appendWindowStart, appendWindowEnd),
+            null));
+      }
     }
 
-    await Promise.all(operations);
+    if (operations.length) {
+      await Promise.all(operations);
+    }
   }
 
   /**
@@ -1841,6 +1850,14 @@ shaka.media.MediaSourceEngine = class {
       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment, uri);
     }
 
+    if (isInitSegment &&
+        Platform.requiresEC3InitSegments() &&
+        shaka.util.MimeUtils.getContainerType(
+            this.sourceBufferTypes_[contentType]) == 'mp4') {
+      shaka.log.debug('Forcing fake EC-3 information in init segment.');
+      segment = shaka.media.ContentWorkarounds.fakeEC3(segment);
+    }
+
     return segment;
   }
 
@@ -2169,7 +2186,8 @@ shaka.media.MediaSourceEngine = class {
     const newMimeType = realInfo.mimeType;
 
     let muxedContentCheck = true;
-    if (transmuxerMuxed) {
+    if (transmuxerMuxed &&
+        ContentType.AUDIO in this.sourceBufferTypes_) {
       const muxedRealInfo =
           this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
       const muxedCurrentCodec = MimeUtils.getNormalizedCodec(

package/lib/media/region_timeline.js

@@ -102,13 +102,14 @@ shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
    * @private
    */
   findSimilarRegion_(region) {
+    const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.1;
     for (const existing of this.regions_) {
       // The same scheme ID and time range means that it is similar-enough to
       // be the same region.
       const isSimilar = existing.schemeIdUri == region.schemeIdUri &&
-                        existing.id == region.id &&
-                        existing.startTime == region.startTime &&
-                        existing.endTime == region.endTime;
+          existing.id == region.id &&
+          isDiffNegligible(existing.startTime, region.startTime) &&
+          isDiffNegligible(existing.endTime, region.endTime);
 
       if (isSimilar) {
         return existing;

package/lib/media/streaming_engine.js

@@ -1314,12 +1314,17 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.clearSelectedClosedCaptionId();
     }
 
+    // Update updateIntervalSeconds according to our current playbackrate,
+    // and always considering a minimum of 1.
+    const updateIntervalSeconds = this.config_.updateIntervalSeconds /
+        Math.max(1, Math.abs(this.playerInterface_.getPlaybackRate()));
+
     if (!this.playerInterface_.mediaSourceEngine.isStreamingAllowed() &&
         mediaState.type != ContentType.TEXT) {
       // It is not allowed to add segments yet, so we schedule an update to
       // check again later. So any prediction we make now could be terribly
       // invalid soon.
-      return this.config_.updateIntervalSeconds / 2;
+      return updateIntervalSeconds / 2;
     }
 
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
@@ -1393,9 +1398,8 @@ shaka.media.StreamingEngine = class {
       shaka.log.v2(logPrefix, 'buffering goal met');
 
       // Do not try to predict the next update.  Just poll according to
-      // configuration (seconds). The playback rate can change at any time, so
-      // any prediction we make now could be terribly invalid soon.
-      return this.config_.updateIntervalSeconds / 2;
+      // configuration (seconds).
+      return updateIntervalSeconds / 2;
     }
 
     // Lack of segment iterator is the best indicator stream has changed.
@@ -1407,7 +1411,7 @@ shaka.media.StreamingEngine = class {
       // In any case just try again... if the manifest is incomplete or is not
       // being updated then we'll idle forever; otherwise, we'll end up getting
       // a SegmentReference eventually.
-      return this.config_.updateIntervalSeconds;
+      return updateIntervalSeconds;
     }
     // Get media state adaptation and reset this value. By guarding it during
     // actual stream change we ensure it won't be cleaned by accident on regular
@@ -1446,7 +1450,7 @@ shaka.media.StreamingEngine = class {
       // For example, let video buffering catch up to audio buffering before
       // fetching another audio segment.
       shaka.log.v2(logPrefix, 'waiting for other streams to buffer');
-      return this.config_.updateIntervalSeconds;
+      return updateIntervalSeconds;
     }
 
     if (mediaState.segmentPrefetch && mediaState.segmentIterator &&
@@ -1509,7 +1513,18 @@ shaka.media.StreamingEngine = class {
       // Something is buffered from the same Stream.  Use the current position
       // in the segment index.  This is updated via next() after each segment is
       // appended.
-      return mediaState.segmentIterator.current();
+      let ref = mediaState.segmentIterator.current();
+      if (ref && mediaState.lastSegmentReference) {
+        // In HLS sometimes the segment iterator adds or removes segments very
+        // quickly, so we have to be sure that we do not add the last segment
+        // again, tolerating a difference of 1ms.
+        const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.001;
+        const lastStartTime = mediaState.lastSegmentReference.startTime;
+        if (isDiffNegligible(lastStartTime, ref.startTime)) {
+          ref = mediaState.segmentIterator.next().value;
+        }
+      }
+      return ref;
     } else if (mediaState.lastSegmentReference || bufferEnd) {
       // Something is buffered from another Stream.
       const time = mediaState.lastSegmentReference ?
@@ -2512,15 +2527,26 @@ shaka.media.StreamingEngine = class {
     }
     const bufferedBehind = presentationTime - startTime;
 
-    const overflow = bufferedBehind - bufferBehind;
+    const evictionGoal = this.config_.evictionGoal;
+
+    const seekRangeStart =
+        this.manifest_.presentationTimeline.getSeekRangeStart();
+    const seekRangeEnd =
+        this.manifest_.presentationTimeline.getSeekRangeEnd();
+
+    let overflow = bufferedBehind - bufferBehind;
+    if (seekRangeEnd - seekRangeStart > evictionGoal) {
+      overflow = Math.max(bufferedBehind - bufferBehind,
+          seekRangeStart - evictionGoal - startTime);
+    }
     // See: https://github.com/shaka-project/shaka-player/issues/6240
-    if (overflow <= this.config_.evictionGoal) {
+    if (overflow <= evictionGoal) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
           'presentationTime=' + presentationTime,
           'bufferedBehind=' + bufferedBehind,
           'bufferBehind=' + bufferBehind,
-          'evictionGoal=' + this.config_.evictionGoal,
+          'evictionGoal=' + evictionGoal,
           'underflow=' + Math.abs(overflow));
       return;
     }
@@ -2530,7 +2556,7 @@ shaka.media.StreamingEngine = class {
         'presentationTime=' + presentationTime,
         'bufferedBehind=' + bufferedBehind,
         'bufferBehind=' + bufferBehind,
-        'evictionGoal=' + this.config_.evictionGoal,
+        'evictionGoal=' + evictionGoal,
         'overflow=' + overflow);
 
     await this.playerInterface_.mediaSourceEngine.remove(mediaState.type,

package/lib/net/http_plugin_utils.js

@@ -30,7 +30,7 @@ shaka.net.HttpPluginUtils = class {
   static makeResponse(headers, data, status, uri, responseURL, requestType) {
     goog.asserts.assert(data, 'Data should be non-null!');
 
-    if (status >= 200 && status <= 299 && status != 202) {
+    if ((status >= 200 && status <= 299 && status != 202) || status == 304) {
       // Most 2xx HTTP codes are success cases.
       /** @type {shaka.extern.Response} */
       const response = {

package/lib/net/networking_engine.js

@@ -667,8 +667,16 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
           const data = (new Map()).set('error', error);
           const event = new shaka.util.FakeEvent('retry', data);
+          // A user can call preventDefault() on a cancelable event.
+          event.cancelable = true;
           this.dispatchEvent(event);
 
+          if (event.defaultPrevented) {
+            // If the caller uses preventDefault() on the 'retry' event, don't
+            // retry any more.
+            throw error;
+          }
+
           // Move to the next URI.
           index = (index + 1) % request.uris.length;
           return this.send_(

package/lib/net/networking_utils.js

@@ -88,6 +88,7 @@ shaka.net.NetworkingUtils.EXTENSIONS_TO_MIME_TYPES_ = {
   'ogg': 'audio/ogg',
   'mpg': 'video/mpeg',
   'mpeg': 'video/mpeg',
+  'mov': 'video/quicktime',
   'm3u8': 'application/x-mpegurl',
   'mpd': 'application/dash+xml',
   'ism': 'application/vnd.ms-sstr+xml',

package/lib/player.js

@@ -53,6 +53,7 @@ goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MapUtils');
 goog.require('shaka.util.MediaReadyState');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mutex');
@@ -1508,6 +1509,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     let preloadManager = null;
     let assetUri = '';
     if (assetUriOrPreloader instanceof shaka.media.PreloadManager) {
+      if (assetUriOrPreloader.isDestroyed()) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.PLAYER,
+            shaka.util.Error.Code.PRELOAD_DESTROYED);
+      }
       preloadManager = assetUriOrPreloader;
       assetUri = preloadManager.getAssetUri() || '';
     } else {
@@ -4225,7 +4232,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       shaka.log.alwaysWarn('A trick play rate of 0 is unsupported!');
       return;
     }
-    this.trickPlayEventManager_.removeAll();
 
     this.playRateController_.set(rate);
 
@@ -4233,26 +4239,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.abrManager_.playbackRateChanged(rate);
       this.streamingEngine_.setTrickPlay(Math.abs(rate) > 1);
     }
-    if (this.isLive()) {
-      this.trickPlayEventManager_.listen(this.video_, 'timeupdate', () => {
-        const currentTime = this.video_.currentTime;
-        const seekRange = this.seekRange();
-        const safeSeekOffset = this.config_.streaming.safeSeekOffset;
-
-        // Cancel trick play if we hit the beginning or end of the seekable
-        // (Sub-second accuracy not required here)
-        if (rate > 0) {
-          if (Math.floor(currentTime) >= Math.floor(seekRange.end)) {
-            this.cancelTrickPlay();
-          }
-        } else {
-          if (Math.floor(currentTime) <=
-              Math.floor(seekRange.start + safeSeekOffset)) {
-            this.cancelTrickPlay();
-          }
-        }
-      });
-    }
+    this.setupTrickPlayEventListeners_(rate);
   }
 
   /**
@@ -4407,7 +4394,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!imageStream.segmentIndex) {
       await imageStream.createSegmentIndex();
     }
-    const promises = [];
+    const thumbnails = [];
     imageStream.segmentIndex.forEachTopLevelReference((reference) => {
       const dimensions = this.parseTilesLayout_(
           reference.getTilesLayout() || imageStream.tilesLayout);
@@ -4416,12 +4403,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const duration = reference.trueEndTime - reference.startTime;
         for (let i = 0; i < numThumbnails; i++) {
           const sampleTime = reference.startTime + duration * i / numThumbnails;
-          promises.push(this.getThumbnails(trackId, sampleTime));
+          const thumbnail =
+              this.getThumbnailsByStream_(
+              /** @type {shaka.extern.Stream} */ (imageStream), sampleTime);
+          if (thumbnail) {
+            thumbnails.push(thumbnail);
+          }
         }
       }
     });
-    const thumbnails = await Promise.all(promises);
-    return thumbnails.filter((t) => t);
+    if (imageStream.closeSegmentIndex) {
+      imageStream.closeSegmentIndex();
+    }
+    return thumbnails;
   }
 
   /**
@@ -4478,6 +4472,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!imageStream.segmentIndex) {
       await imageStream.createSegmentIndex();
     }
+
+    return this.getThumbnailsByStream_(imageStream, time);
+  }
+
+  /**
+   * Return a Thumbnail object from a image stream and time.
+   *
+   * @param {shaka.extern.Stream} imageStream
+   * @param {number} time
+   * @return {?shaka.extern.Thumbnail}
+   * @private
+   */
+  getThumbnailsByStream_(imageStream, time) {
     const referencePosition = imageStream.segmentIndex.find(time);
     if (referencePosition == null) {
       return null;
@@ -6171,6 +6178,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // The playback rate has changed. This could be us or someone else.
       // If this was us, setting the rate again will be a no-op.
       this.playRateController_.set(newRate);
+
+      if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
+        this.abrManager_.playbackRateChanged(newRate);
+      }
+      this.setupTrickPlayEventListeners_(newRate);
     }
 
     const event = shaka.Player.makeEvent_(
@@ -6178,6 +6190,36 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(event);
   }
 
+  /**
+   * Configures all the necessary listeners when trick play is being performed.
+   *
+   * @param {number} rate
+   * @private
+   */
+  setupTrickPlayEventListeners_(rate) {
+    this.trickPlayEventManager_.removeAll();
+    if (this.isLive()) {
+      this.trickPlayEventManager_.listen(this.video_, 'timeupdate', () => {
+        const currentTime = this.video_.currentTime;
+        const seekRange = this.seekRange();
+        const safeSeekOffset = this.config_.streaming.safeSeekOffset;
+
+        // Cancel trick play if we hit the beginning or end of the seekable
+        // (Sub-second accuracy not required here)
+        if (rate > 0) {
+          if (Math.floor(currentTime) >= Math.floor(seekRange.end)) {
+            this.cancelTrickPlay();
+          }
+        } else {
+          if (Math.floor(currentTime) <=
+              Math.floor(seekRange.start + safeSeekOffset)) {
+            this.cancelTrickPlay();
+          }
+        }
+      });
+    }
+  }
+
   /**
    * Try updating the state history. If the player has not finished
    * initializing, this will be a no-op.
@@ -7255,6 +7297,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Only filter tracks for keys if we have some key statuses to look at.
     if (keyIds.length) {
+      const currentKeySystem = this.keySystem();
+      const clearKeys = shaka.util.MapUtils.asMap(this.config_.drm.clearKeys);
+
       for (const variant of this.manifest_.variants) {
         const streams = shaka.util.StreamUtils.getVariantStreams(variant);
 
@@ -7264,16 +7309,42 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           // Only update if we have key IDs for the stream.  If the keys aren't
           // all present, then the track should be restricted.
           if (stream.keyIds.size) {
-            variant.allowedByKeySystem = true;
-
-            for (const keyId of stream.keyIds) {
-              const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
-              if (keyStatus || this.drmEngine_.hasManifestInitData()) {
-                variant.allowedByKeySystem = variant.allowedByKeySystem &&
-                    !!keyStatus && !restrictedStatuses.includes(keyStatus);
-              }
-            }
-          }
+            // If we are not using clearkeys, and the stream has drmInfos we
+            // only want to check the keyIds of the keySystem we are using.
+            // Other keySystems might have other keyIds that might not be
+            // valid in this case. This can happen in HLS if the manifest
+            // has Widevine with keyIds and PlayReady without keyIds and we are
+            // using PlayReady.
+            if (stream.drmInfos.length && !clearKeys.size) {
+              for (const drmInfo of stream.drmInfos) {
+                if (drmInfo.keyIds.size &&
+                    drmInfo.keySystem == currentKeySystem) {
+                  variant.allowedByKeySystem = true;
+
+                  for (const keyId of drmInfo.keyIds) {
+                    const keyStatus =
+                        keyStatusMap[isGlobalStatus ? '00' : keyId];
+                    if (keyStatus || this.drmEngine_.hasManifestInitData()) {
+                      variant.allowedByKeySystem =
+                          variant.allowedByKeySystem &&
+                          !!keyStatus &&
+                          !restrictedStatuses.includes(keyStatus);
+                    } // if (keyStatus || this.drmEngine_.hasManifestInitData())
+                  } // for (const keyId of drmInfo.keyIds)
+                } // if (drmInfo.keyIds.size && ...
+              } // for (const drmInfo of stream.drmInfos
+            } else {
+              variant.allowedByKeySystem = true;
+
+              for (const keyId of stream.keyIds) {
+                const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
+                if (keyStatus || this.drmEngine_.hasManifestInitData()) {
+                  variant.allowedByKeySystem = variant.allowedByKeySystem &&
+                      !!keyStatus && !restrictedStatuses.includes(keyStatus);
+                }
+              } // for (const keyId of stream.keyIds)
+            } // if (stream.drmInfos.length && !clearKeys.size)
+          } // if (stream.keyIds.size)
 
           if (originalAllowed != variant.allowedByKeySystem) {
             tracksChanged = true;
@@ -7542,7 +7613,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.video_ || this.video_.ended) {
       return true;
     }
-    return !this.isLive() && this.video_.currentTime >= this.seekRange().end;
+    return this.fullyLoaded_ && !this.isLive() &&
+        this.video_.currentTime >= this.seekRange().end;
   }
 };
 
@@ -7585,7 +7657,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat, max-len
-shaka.Player.version = 'v4.9.35' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.9.36' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.