shaka-player 4.12.3 → 4.12.5

package/lib/ads/interstitial_ad.js

@@ -144,7 +144,7 @@ shaka.ads.InterstitialAd = class {
    * @export
    */
   canSkipNow() {
-    return this.getTimeUntilSkippable() == 0;
+    return this.isSkippable_ && this.getTimeUntilSkippable() == 0;
   }
 
   /**
@@ -152,7 +152,9 @@ shaka.ads.InterstitialAd = class {
    * @export
    */
   skip() {
-    this.onSkip_();
+    if (this.canSkipNow()) {
+      this.onSkip_();
+    }
   }
 
   /**

package/lib/ads/interstitial_ad_manager.js

@@ -704,7 +704,6 @@ shaka.ads.InterstitialAdManager = class {
       this.onEvent_(new shaka.util.FakeEvent(
           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
     }
-    const eventsSent = new Set();
     this.adEventManager_.listenOnce(this.player_, 'error', error);
     this.adEventManager_.listen(this.video_, 'timeupdate', () => {
       const duration = this.video_.duration;
@@ -718,23 +717,21 @@ shaka.ads.InterstitialAdManager = class {
             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
       }
       prevCanSkipNow = currentCanSkipNow;
-      const currentPercent = 100 * this.video_.currentTime / duration;
-      if (currentPercent >= 25 && !eventsSent.has('firstquartile')) {
-        updateBaseVideoTime();
-        this.onEvent_(
-            new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
-        eventsSent.add('firstquartile');
-      } else if (currentPercent >= 50 && !eventsSent.has('midpoint')) {
-        updateBaseVideoTime();
-        this.onEvent_(
-            new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
-        eventsSent.add('midpoint');
-      } else if (currentPercent >= 75 && !eventsSent.has('thirdquartile')) {
-        updateBaseVideoTime();
-        this.onEvent_(
-            new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
-        eventsSent.add('thirdquartile');
-      }
+    });
+    this.adEventManager_.listenOnce(this.player_, 'firstquartile', () => {
+      updateBaseVideoTime();
+      this.onEvent_(
+          new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
+    });
+    this.adEventManager_.listenOnce(this.player_, 'midpoint', () => {
+      updateBaseVideoTime();
+      this.onEvent_(
+          new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
+    });
+    this.adEventManager_.listenOnce(this.player_, 'thirdquartile', () => {
+      updateBaseVideoTime();
+      this.onEvent_(
+          new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
     });
     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
     this.adEventManager_.listen(this.video_, 'play', () => {

package/lib/dash/dash_parser.js

@@ -1505,6 +1505,9 @@ shaka.dash.DashParser = class {
       let shouldDeleteIndex = true;
       for (const contextId of this.indexStreamMap_[pId]) {
         const stream = this.streamMap_[contextId];
+        if (!stream) {
+          continue;
+        }
         if (stream.segmentIndex && !stream.segmentIndex.isEmpty()) {
           shouldDeleteIndex = false;
           continue;

package/lib/media/drm_engine.js

@@ -9,12 +9,14 @@ goog.provide('shaka.media.DrmEngine');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.DrmUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.ManifestParserUtils');
@@ -66,12 +68,18 @@ shaka.media.DrmEngine = class {
      */
     this.activeSessions_ = new Map();
 
+    /** @private {!Array.<!shaka.net.NetworkingEngine.PendingRequest>} */
+    this.activeRequests_ = [];
+
     /**
      * @private {!Map<string,
      *           {initData: ?Uint8Array, initDataType: ?string}>}
      */
     this.storedPersistentSessions_ = new Map();
 
+    /** @private {boolean} */
+    this.hasInitData_ = false;
+
     /** @private {!shaka.util.PublicPromise} */
     this.allSessionsLoaded_ = new shaka.util.PublicPromise();
 
@@ -705,6 +713,7 @@ shaka.media.DrmEngine = class {
 
       // Reset the promise for the next sessions to come if key needs aren't
       // satisfied with persistent sessions
+      this.hasInitData_ = false;
       this.allSessionsLoaded_ = new shaka.util.PublicPromise();
       this.allSessionsLoaded_.catch(() => {});
     }
@@ -766,11 +775,16 @@ shaka.media.DrmEngine = class {
       }
     }
 
+    // Mark that there is init data, so that the preloader will know to wait
+    // for sessions to be loaded.
+    this.hasInitData_ = true;
+
     // If there are pre-existing sessions that have all been loaded
     // then reset the allSessionsLoaded_ promise, which can now be
     // used to wait for new sesssions to be loaded
     if (this.activeSessions_.size > 0 && this.areAllSessionsLoaded_()) {
       this.allSessionsLoaded_.resolve();
+      this.hasInitData_ = false;
       this.allSessionsLoaded_ = new shaka.util.PublicPromise();
       this.allSessionsLoaded_.catch(() => {});
     }
@@ -914,14 +928,16 @@ shaka.media.DrmEngine = class {
           'Got MediaKeySystemAccess with configuration',
           realConfig);
 
+      const keySystem =
+          this.config_.keySystemsMapping[mediaKeySystemAccess.keySystem] ||
+          mediaKeySystemAccess.keySystem;
+
       if (variants.length) {
         this.currentDrmInfo_ = this.createDrmInfoByInfos_(
-            mediaKeySystemAccess.keySystem,
-            drmInfosByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, drmInfosByKeySystem.get(keySystem));
       } else {
         this.currentDrmInfo_ = shaka.media.DrmEngine.createDrmInfoByConfigs_(
-            mediaKeySystemAccess.keySystem,
-            configsByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, configsByKeySystem.get(keySystem));
       }
       if (!this.currentDrmInfo_.licenseServerUri) {
         throw new shaka.util.Error(
@@ -1036,8 +1052,12 @@ shaka.media.DrmEngine = class {
           if (!decodingInfo.supported || !decodingInfo.keySystemAccess) {
             continue;
           }
-          const drmInfos =
-              drmInfosByKeySystem.get(decodingInfo.keySystemAccess.keySystem);
+          const originalKeySystem = decodingInfo.keySystemAccess.keySystem;
+          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;
@@ -1380,6 +1400,14 @@ shaka.media.DrmEngine = class {
             this.video_.paused && !this.initialRequestsSent_);
   }
 
+  /** @return {!Promise} */
+  async waitForActiveRequests() {
+    if (this.hasInitData_) {
+      await this.allSessionsLoaded_;
+      await Promise.all(this.activeRequests_.map((req) => req.promise));
+    }
+  }
+
   /**
    * Sends a license request.
    * @param {!MediaKeyMessageEvent} event
@@ -1439,7 +1467,9 @@ shaka.media.DrmEngine = class {
     try {
       const req = this.playerInterface_.netEngine.request(
           requestType, request, {isPreload: this.isPreload_()});
+      this.activeRequests_.push(req);
       response = await req.promise;
+      shaka.util.ArrayUtils.remove(this.activeRequests_, req);
     } catch (error) {
       if (this.destroyer_.destroyed()) {
         return;
@@ -1859,9 +1889,16 @@ shaka.media.DrmEngine = class {
         offlineConfig.sessionTypes = ['persistent-license'];
 
         const configs = [offlineConfig, basicConfig];
-
-        const access = await navigator.requestMediaKeySystemAccess(
-            keySystem, configs);
+        // On some (Android) WebView environments,
+        // requestMediaKeySystemAccess will
+        // not resolve or reject, at least if RESOURCE_PROTECTED_MEDIA_ID
+        // is not set.  This is a workaround for that issue.
+        const TIMEOUT_FOR_CHECKACCESS_IN_SECONDS = 1;
+        const access =
+          await shaka.util.Functional.promiseWithTimeout(
+              TIMEOUT_FOR_CHECKACCESS_IN_SECONDS,
+              navigator.requestMediaKeySystemAccess(keySystem, configs),
+          );
         await processMediaKeySystemAccess(keySystem, access);
       } catch (error) {}  // Ignore errors.
     };
@@ -1896,13 +1933,22 @@ shaka.media.DrmEngine = class {
             },
           },
         };
-
+        // On some (Android) WebView environments, decodingInfo will
+        // not resolve or reject, at least if RESOURCE_PROTECTED_MEDIA_ID
+        // is not set.  This is a workaround for that issue.
+        const TIMEOUT_FOR_DECODING_INFO_IN_SECONDS = 1;
         const decodingInfo =
-            await navigator.mediaCapabilities.decodingInfo(decodingConfig);
+          await shaka.util.Functional.promiseWithTimeout(
+              TIMEOUT_FOR_DECODING_INFO_IN_SECONDS,
+              navigator.mediaCapabilities.decodingInfo(decodingConfig),
+          );
 
         const access = decodingInfo.keySystemAccess;
         await processMediaKeySystemAccess(keySystem, access);
-      } catch (error) {}  // Ignore errors.
+      } catch (error) {
+        // Ignore errors.
+        shaka.log.v2('Failed to probe support for', keySystem, error);
+      }
     };
 
     // Initialize the support structure for each key system.
@@ -1961,18 +2007,10 @@ shaka.media.DrmEngine = class {
    * @private
    */
   async closeSession_(session) {
-    const DrmEngine = shaka.media.DrmEngine;
-
-    const timeout = new Promise((resolve, reject) => {
-      const timer = new shaka.util.Timer(reject);
-      timer.tickAfter(DrmEngine.CLOSE_TIMEOUT_);
-    });
-
     try {
-      await Promise.race([
-        Promise.all([session.close(), session.closed]),
-        timeout,
-      ]);
+      await shaka.util.Functional.promiseWithTimeout(
+          shaka.media.DrmEngine.CLOSE_TIMEOUT_,
+          Promise.all([session.close(), session.closed]));
     } catch (e) {
       shaka.log.warning('Timeout waiting for session close');
     }

package/lib/media/manifest_filterer.js

@@ -50,7 +50,8 @@ shaka.media.ManifestFilterer = class {
   async filterManifest(manifest) {
     goog.asserts.assert(manifest, 'Manifest should exist!');
     await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest,
-        this.config_.drm.preferredKeySystems);
+        this.config_.drm.preferredKeySystems,
+        this.config_.drm.keySystemsMapping);
     if (!this.config_.streaming.dontChooseCodecs) {
       shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
           manifest,

package/lib/media/media_source_engine.js

@@ -466,12 +466,12 @@ shaka.media.MediaSourceEngine = class {
       cleanup.push(this.textEngine_.destroy());
     }
 
+    await Promise.all(cleanup);
+
     for (const contentType in this.transmuxers_) {
-      cleanup.push(this.transmuxers_[contentType].destroy());
+      this.transmuxers_[contentType].destroy();
     }
 
-
-    await Promise.all(cleanup);
     if (this.eventManager_) {
       this.eventManager_.release();
       this.eventManager_ = null;
@@ -692,7 +692,8 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   isStreamingAllowed() {
-    return this.streamingAllowed_ && !this.usingRemotePlayback_;
+    return this.streamingAllowed_ && !this.usingRemotePlayback_ &&
+        !this.reloadingMediaSource_;
   }
 
   /**
@@ -1859,11 +1860,13 @@ shaka.media.MediaSourceEngine = class {
 
     /** @type {!Array.<!shaka.util.PublicPromise>} */
     const allWaiters = [];
+    /** @type {!Array.<!shaka.util.ManifestParserUtils.ContentType>} */
+    const contentTypes = Object.keys(this.sourceBuffers_);
 
     // Enqueue a 'wait' operation onto each queue.
     // This operation signals its readiness when it starts.
     // When all wait operations are ready, the real operation takes place.
-    for (const contentType in this.sourceBuffers_) {
+    for (const contentType of contentTypes) {
       const ready = new shaka.util.PublicPromise();
       const operation = {
         start: () => ready.resolve(),
@@ -1893,7 +1896,7 @@ shaka.media.MediaSourceEngine = class {
       // assert at the end of destroy passes.  In compiled mode, the queues
       // are wiped in destroy.
       if (goog.DEBUG) {
-        for (const contentType in this.sourceBuffers_) {
+        for (const contentType of contentTypes) {
           if (this.queues_[contentType].length) {
             goog.asserts.assert(
                 this.queues_[contentType].length == 1,
@@ -1910,7 +1913,7 @@ shaka.media.MediaSourceEngine = class {
 
     if (goog.DEBUG) {
       // If we did it correctly, nothing is updating.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         goog.asserts.assert(
             this.sourceBuffers_[contentType].updating == false,
             'SourceBuffers should not be updating after a blocking op!');
@@ -1930,7 +1933,7 @@ shaka.media.MediaSourceEngine = class {
           null);
     } finally {
       // Unblock the queues.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         this.popFromQueue_(contentType);
       }
     }
@@ -1942,6 +1945,7 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   popFromQueue_(contentType) {
+    goog.asserts.assert(this.queues_[contentType], 'Queue should exist');
     // Remove the in-progress operation, which is now complete.
     this.queues_[contentType].shift();
     this.startOperation_(contentType);
@@ -2099,48 +2103,6 @@ shaka.media.MediaSourceEngine = class {
         null);
   }
 
-  /**
-   * Returns the source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @return {?shaka.media.MediaSourceEngine.SourceBufferParams}
-   * @private
-   */
-  getSourceBufferParams_(contentType) {
-    if (!this.sourceBuffers_[contentType]) {
-      return null;
-    }
-    return {
-      timestampOffset: this.sourceBuffers_[contentType].timestampOffset,
-      appendWindowStart: this.sourceBuffers_[contentType].appendWindowStart,
-      appendWindowEnd: this.sourceBuffers_[contentType].appendWindowEnd,
-    };
-  }
-
-  /**
-   * Restore source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {?shaka.media.MediaSourceEngine.SourceBufferParams} params
-   * @private
-   */
-  restoreSourceBufferParams_(contentType, params) {
-    if (!params) {
-      return;
-    }
-
-    if (!this.sourceBuffers_[contentType]) {
-      shaka.log.warning('Attempted to restore a non-existent source buffer');
-      return;
-    }
-
-    this.sourceBuffers_[contentType].timestampOffset =
-      params.timestampOffset;
-    // `end` needs to be set before `start`
-    this.sourceBuffers_[contentType].appendWindowEnd =
-      params.appendWindowEnd;
-    this.sourceBuffers_[contentType].appendWindowStart =
-      params.appendWindowStart;
-  }
-
   /**
    * Resets the MediaSource and re-adds source buffers due to codec mismatch
    *
@@ -2149,7 +2111,6 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   async reset_(streamsByType) {
-    const Functional = shaka.util.Functional;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     this.reloadingMediaSource_ = true;
     this.needSplitMuxedContent_ = false;
@@ -2171,36 +2132,19 @@ shaka.media.MediaSourceEngine = class {
     try {
       this.eventManager_.removeAll();
 
-      const cleanup = [];
       for (const contentType in this.transmuxers_) {
-        cleanup.push(this.transmuxers_[contentType].destroy());
-      }
-      for (const contentType in this.queues_) {
-        // Make a local copy of the queue and the first item.
-        const q = this.queues_[contentType];
-        const inProgress = q[0];
-
-        // Drop everything else out of the original queue.
-        this.queues_[contentType] = q.slice(0, 1);
-
-        // We will wait for this item to complete/fail.
-        if (inProgress) {
-          cleanup.push(inProgress.p.catch(Functional.noop));
-        }
-
-        // The rest will be rejected silently if possible.
-        for (const item of q.slice(1)) {
-          item.p.reject(shaka.util.Destroyer.destroyedError());
-        }
+        this.transmuxers_[contentType].destroy();
       }
       for (const contentType in this.sourceBuffers_) {
         const sourceBuffer = this.sourceBuffers_[contentType];
         try {
           this.mediaSource_.removeSourceBuffer(sourceBuffer);
-        } catch (e) {}
+        } catch (e) {
+          shaka.log.debug('Exception on removeSourceBuffer', e);
+        }
       }
-      await Promise.all(cleanup);
       this.transmuxers_ = {};
+      this.sourceBuffers_ = {};
 
       const previousDuration = this.mediaSource_.duration;
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
@@ -2231,23 +2175,17 @@ shaka.media.MediaSourceEngine = class {
           onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
-        const previousParams = this.getSourceBufferParams_(contentType);
         const stream = streamsByType.get(contentType);
         // eslint-disable-next-line no-await-in-loop
         await this.initSourceBuffer_(contentType, stream, stream.codecs);
-        if (this.needSplitMuxedContent_) {
-          this.queues_[ContentType.AUDIO] = [];
-          this.queues_[ContentType.VIDEO] = [];
-        } else {
-          this.queues_[contentType] = [];
-        }
-
-        this.restoreSourceBufferParams_(contentType, previousParams);
       }
       const audio = streamsByType.get(ContentType.AUDIO);
       if (audio && audio.isAudioMuxedInVideo) {
         this.needSplitMuxedContent_ = true;
       }
+      if (this.needSplitMuxedContent_ && !this.queues_[ContentType.AUDIO]) {
+        this.queues_[ContentType.AUDIO] = [];
+      }
 
       // Fake a seek to catchup the playhead.
       this.video_.currentTime = currentTime;
@@ -2393,13 +2331,12 @@ shaka.media.MediaSourceEngine = class {
    * Returns true if it's necessary codec switch to load the new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} refMimeType
    * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
+  isCodecSwitchNecessary_(contentType, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -2443,13 +2380,12 @@ shaka.media.MediaSourceEngine = class {
    * new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} mimeType
    * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
+  isResetMediaSourceNecessary(contentType, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, mimeType, codecs)) {
       return false;
     }
 
@@ -2540,12 +2476,3 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  */
 shaka.media.MediaSourceEngine.PlayerInterface;
-
-/**
- * @typedef {{
- *   timestampOffset: number,
- *   appendWindowStart: number,
- *   appendWindowEnd: number
- * }}
- */
-shaka.media.MediaSourceEngine.SourceBufferParams;

package/lib/media/preload_manager.js

@@ -398,7 +398,13 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
         await this.initializeDrmInner_();
         this.throwIfDestroyed_();
 
-        await this.chooseInitialVariantInner_();
+        await this.chooseInitialVariantAndPrefetchInner_();
+        this.throwIfDestroyed_();
+
+        // We don't need the drm keys to load completely for the initial variant
+        // to be chosen, but we won't mark the load as a success until it has
+        // been loaded. So wait for it here, not inside initializeDrmInner_.
+        await this.drmEngine_.waitForActiveRequests();
         this.throwIfDestroyed_();
 
         this.successPromise_.resolve();
@@ -610,12 +616,12 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
 
   /**
    * Performs a final filtering of the manifest, and chooses the initial
-   * variant.
+   * variant. Also prefetches segments.
    *
    * @return {!Promise}
    * @private
    */
-  async chooseInitialVariantInner_() {
+  async chooseInitialVariantAndPrefetchInner_() {
     goog.asserts.assert(
         this.manifest_, 'The manifest should already be parsed.');
 

package/lib/media/streaming_engine.js

@@ -2011,7 +2011,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream, mimeType, fullCodecs);
+              mediaState.type, mimeType, fullCodecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -2025,6 +2025,10 @@ shaka.media.StreamingEngine = class {
           // Then clear our cache of the last init segment, since MSE will be
           // reloaded and no init segment will be there post-reload.
           otherState.lastInitSegmentReference = null;
+          // Clear cache of append window start and end, since they will need
+          // to be reapplied post-reload by streaming engine.
+          otherState.lastAppendWindowStart = null;
+          otherState.lastAppendWindowEnd = null;
           // Now force the existing buffer to be cleared.  It is not necessary
           // to perform the MSE clear operation, but this has the side-effect
           // that our state for that stream will then match MSE's post-reload
@@ -2729,6 +2733,8 @@ shaka.media.StreamingEngine = class {
     const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
     if (audioMediaState) {
       audioMediaState.lastInitSegmentReference = null;
+      audioMediaState.lastAppendWindowStart = null;
+      audioMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(audioMediaState);
       }
@@ -2740,6 +2746,8 @@ shaka.media.StreamingEngine = class {
     const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
     if (videoMediaState) {
       videoMediaState.lastInitSegmentReference = null;
+      videoMediaState.lastAppendWindowStart = null;
+      videoMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(videoMediaState);
       }

package/lib/offline/storage.js

@@ -702,7 +702,7 @@ shaka.offline.Storage = class {
     // to play later (no point storing something we can't play).
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
         drmEngine, manifest, config.offline.usePersistentLicense,
-        config.drm.preferredKeySystems);
+        config.drm.preferredKeySystems, config.drm.keySystemsMapping);
 
     // Gather all tracks.
     const allTracks = [];

package/lib/player.js

@@ -1508,7 +1508,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // after several playbacks, and they are not able anymore to properly
       // create MediaKeys objects. To prevent it, clear the cache after
       // each playback.
-      if (this.config_.streaming.clearDecodingCache) {
+      if (this.config_ && this.config_.streaming.clearDecodingCache) {
         shaka.util.StreamUtils.clearDecodingConfigCache();
         shaka.util.DrmUtils.clearMediaKeySystemAccessMap();
       }
@@ -3136,15 +3136,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.reject(this.videoErrorToShakaError_());
     });
 
-    const timeout = new Promise((resolve, reject) => {
-      const timer = new shaka.util.Timer(reject);
-      timer.tickAfter(this.config_.streaming.loadTimeout);
-    });
-
-    await Promise.race([
-      fullyLoaded,
-      timeout,
-    ]);
+    await shaka.util.Functional.promiseWithTimeout(
+        this.config_.streaming.loadTimeout, fullyLoaded);
 
     const isLive = this.isLive();
 
@@ -6984,7 +6977,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           's). Updating playbackRate to ' + minPlaybackRate);
         this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
       }
-    } else if (maxLatency && maxPlaybackRate &&
+    } else if (maxLatency != undefined && maxPlaybackRate &&
       (latency - offset) > maxLatency) {
       if (playbackRate != maxPlaybackRate) {
         shaka.log.debug('Latency (' + latency + 's) is greater than ' +
@@ -6993,7 +6986,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.trickPlay(maxPlaybackRate, /* useTrickPlayTrack= */ false);
       }
       this.targetLatencyReached_ = null;
-    } else if (minLatency && minPlaybackRate &&
+    } else if (minLatency != undefined && minPlaybackRate &&
         (latency - offset) < minLatency) {
       if (playbackRate != minPlaybackRate) {
         shaka.log.debug('Latency (' + latency + 's) is smaller than ' +
@@ -8275,7 +8268,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat, max-len
-shaka.Player.version = 'v4.12.3' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.12.5' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.