shaka-player 4.8.10 → 4.9.1

package/lib/media/segment_utils.js

@@ -41,6 +41,7 @@ shaka.media.SegmentUtils = class {
       sampleRate: null,
       closedCaptions: new Map(),
       videoRange: null,
+      colorGamut: null,
     };
   }
 
@@ -125,6 +126,7 @@ shaka.media.SegmentUtils = class {
       sampleRate: null,
       closedCaptions: closedCaptions,
       videoRange: null,
+      colorGamut: null,
     };
   }
 
@@ -199,6 +201,8 @@ shaka.media.SegmentUtils = class {
     let sampleRate = null;
     /** @type {?string} */
     let realVideoRange = null;
+    /** @type {?string} */
+    let realColorGamut = null;
 
     /** @type {?string} */
     let baseBox;
@@ -371,8 +375,10 @@ shaka.media.SegmentUtils = class {
         })
 
         .box('colr', (box) => {
-          const {videoRange} = shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
+          const {videoRange, colorGamut} =
+              shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
           realVideoRange = videoRange;
+          realColorGamut = colorGamut;
         })
 
         .parse(initData || data, /* partialOkay= */ true);
@@ -404,6 +410,7 @@ shaka.media.SegmentUtils = class {
       sampleRate: sampleRate,
       closedCaptions: closedCaptions,
       videoRange: realVideoRange,
+      colorGamut: realColorGamut,
     };
   }
 
@@ -465,7 +472,9 @@ shaka.media.SegmentUtils = class {
       return codecs;
     }
     const dolbyVision = codecs.find((codec) => {
-      return codec.startsWith('dvh1.') || codec.startsWith('dvhe.');
+      return codec.startsWith('dvh1.') ||
+          codec.startsWith('dvhe.') ||
+          codec.startsWith('dav1.');
     });
     if (!dolbyVision) {
       return codecs;
@@ -518,7 +527,8 @@ shaka.media.SegmentUtils = class {
  *   channelCount: ?number,
  *   sampleRate: ?number,
  *   closedCaptions: Map.<string, string>,
- *   videoRange: ?string
+ *   videoRange: ?string,
+ *   colorGamut: ?string
  * }}
  *
  * @property {string} type
@@ -531,5 +541,6 @@ shaka.media.SegmentUtils = class {
  * @property {?number} sampleRate
  * @property {Map.<string, string>} closedCaptions
  * @property {?string} videoRange
+ * @property {?string} colorGamut
  */
 shaka.media.SegmentUtils.BasicInfo;

package/lib/mss/mss_parser.js

@@ -419,6 +419,7 @@ shaka.mss.MssParser = class {
         ignoreManifestTimestampsInSegmentsMode: false,
         type: shaka.media.ManifestParser.MSS,
         serviceDescription: null,
+        nextUrl: null,
       };
 
       // This is the first point where we have a meaningful presentation start
@@ -570,6 +571,7 @@ shaka.mss.MssParser = class {
       spatialAudio: false,
       closedCaptions: null,
       hdr: undefined,
+      colorGamut: undefined,
       videoLayout: undefined,
       tilesLayout: undefined,
       matchedStreams: [],

package/lib/net/http_plugin_utils.js

@@ -58,7 +58,8 @@ shaka.net.HttpPluginUtils = class {
           status,
           responseText,
           headers,
-          requestType);
+          requestType,
+          responseURL || uri);
     }
   }
 };

package/lib/net/networking_engine.js

@@ -96,10 +96,21 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     /** @private {?shaka.net.NetworkingEngine.OnResponse} */
     this.onResponse_ = onResponse || null;
 
+    /** @private {boolean} */
+    this.forceHTTP_ = false;
+
     /** @private {boolean} */
     this.forceHTTPS_ = false;
   }
 
+  /**
+   * @param {boolean} forceHTTP
+   * @export
+   */
+  setForceHTTP(forceHTTP) {
+    this.forceHTTP_ = forceHTTP;
+  }
+
   /**
    * @param {boolean} forceHTTPS
    * @export
@@ -463,6 +474,9 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    */
   send_(type, request, context, backoff, index, lastError,
       numBytesRemainingObj) {
+    if (this.forceHTTP_) {
+      request.uris[index] = request.uris[index].replace('https://', 'http://');
+    }
     if (this.forceHTTPS_) {
       request.uris[index] = request.uris[index].replace('http://', 'https://');
     }

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -158,6 +158,7 @@ shaka.offline.indexeddb.V1StorageCell = class
       frameRate: old.frameRate,
       pixelAspectRatio: undefined,
       hdr: undefined,
+      colorGamut: undefined,
       videoLayout: undefined,
       kind: old.kind,
       language: old.language,

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -107,6 +107,7 @@ shaka.offline.indexeddb.V2StorageCell = class
       frameRate: old.frameRate,
       pixelAspectRatio: old.pixelAspectRatio,
       hdr: undefined,
+      colorGamut: undefined,
       videoLayout: undefined,
       kind: old.kind,
       language: old.language,

package/lib/offline/manifest_converter.js

@@ -93,6 +93,7 @@ shaka.offline.ManifestConverter = class {
       ignoreManifestTimestampsInSegmentsMode: false,
       type: manifestDB.type || shaka.media.ManifestParser.UNKNOWN,
       serviceDescription: null,
+      nextUrl: null,
     };
   }
 
@@ -191,6 +192,7 @@ shaka.offline.ManifestConverter = class {
       frameRate: streamDB.frameRate,
       pixelAspectRatio: streamDB.pixelAspectRatio,
       hdr: streamDB.hdr,
+      colorGamut: streamDB.colorGamut,
       videoLayout: streamDB.videoLayout,
       kind: streamDB.kind,
       encrypted: streamDB.encrypted,

package/lib/offline/storage.js

@@ -1316,6 +1316,7 @@ shaka.offline.Storage = class {
       frameRate: stream.frameRate,
       pixelAspectRatio: stream.pixelAspectRatio,
       hdr: stream.hdr,
+      colorGamut: stream.colorGamut,
       videoLayout: stream.videoLayout,
       kind: stream.kind,
       language: stream.language,

package/lib/player.js

@@ -582,6 +582,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.trickPlayEventManager_ = new shaka.util.EventManager();
 
+    /**
+     * For listeners scoped to the lifetime of the ad manager.
+     * @private {shaka.util.EventManager}
+     */
+    this.adManagerEventManager_ = new shaka.util.EventManager();
+
     /** @private {shaka.net.NetworkingEngine} */
     this.networkingEngine_ = null;
 
@@ -708,7 +714,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.lastTextFactory_;
 
-    /** @private {{width: number, height: number}} */
+    /** @private {shaka.extern.Resolution} */
     this.maxHwRes_ = {width: Infinity, height: Infinity};
 
     /** @private {!shaka.media.ManifestFilterer} */
@@ -758,14 +764,78 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.cmsdManager_ = this.createCmsd_();
 
     this.networkingEngine_ = this.createNetworkingEngine();
+    this.networkingEngine_.setForceHTTP(this.config_.streaming.forceHTTP);
     this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
 
     /** @private {shaka.extern.IAdManager} */
     this.adManager_ = null;
 
+    /** @private {?shaka.media.PreloadManager} */
+    this.preloadDueAdManager_ = null;
+
+    /** @private {HTMLMediaElement} */
+    this.preloadDueAdManagerVideo_ = null;
+
+    /** @private {shaka.util.Timer} */
+    this.preloadDueAdManagerTimer_ = new shaka.util.Timer(async () => {
+      if (this.preloadDueAdManager_) {
+        goog.asserts.assert(this.preloadDueAdManagerVideo_, 'Must have video');
+        await this.attach(
+            this.preloadDueAdManagerVideo_, /* initializeMediaSource= */ true);
+        await this.load(this.preloadDueAdManager_);
+        this.preloadDueAdManagerVideo_.play();
+        this.preloadDueAdManager_ = null;
+      }
+    });
+
     if (shaka.Player.adManagerFactory_) {
       this.adManager_ = shaka.Player.adManagerFactory_();
       this.adManager_.configure(this.config_.ads);
+
+      // Note: we don't use shaka.ads.AdManager.AD_STARTED to avoid add a
+      // optional module in the player.
+      this.adManagerEventManager_.listen(
+          this.adManager_, 'ad-started', async (e) => {
+            if (this.config_.ads.supportsMultipleMediaElements) {
+              return;
+            }
+            const event = /** @type {?google.ima.AdEvent} */
+              (e['originalEvent']);
+            if (!event) {
+              return;
+            }
+            const contentPauseRequested =
+                google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED;
+            if (event.type != contentPauseRequested) {
+              return;
+            }
+            this.preloadDueAdManagerTimer_.stop();
+            if (!this.preloadDueAdManager_) {
+              this.preloadDueAdManagerVideo_ = this.video_;
+              this.preloadDueAdManager_ =
+                await this.detachAndSavePreload(true);
+            }
+          });
+
+      // Note: we don't use shaka.ads.AdManager.AD_STOPPED to avoid add a
+      // optional module in the player.
+      this.adManagerEventManager_.listen(
+          this.adManager_, 'ad-stopped', (e) => {
+            if (this.config_.ads.supportsMultipleMediaElements) {
+              return;
+            }
+            const event = /** @type {?google.ima.AdEvent} */
+              (e['originalEvent']);
+            if (!event) {
+              return;
+            }
+            const contentResumeRequested =
+                google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED;
+            if (event.type != contentResumeRequested) {
+              return;
+            }
+            this.preloadDueAdManagerTimer_.tickAfter(0.1);
+          });
     }
 
     // If the browser comes back online after being offline, then try to play
@@ -779,6 +849,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.checkVariantsTimer_ =
         new shaka.util.Timer(() => this.checkVariants_());
 
+    /** @private {?shaka.media.PreloadManager} */
+    this.preloadNextUrl_ = null;
+
     // 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.
@@ -913,6 +986,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.trickPlayEventManager_.release();
       this.trickPlayEventManager_ = null;
     }
+    if (this.adManagerEventManager_) {
+      this.adManagerEventManager_.release();
+      this.adManagerEventManager_ = null;
+    }
 
     this.abrManagerFactory_ = null;
     this.config_ = null;
@@ -1030,10 +1107,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     const manifest = shaka.media.ManifestParser.probeSupport();
     const media = shaka.media.MediaSourceEngine.probeSupport();
+    const hardwareResolution =
+        await shaka.util.Platform.detectMaxHardwareResolution();
+
+    /** @type {shaka.extern.SupportType} */
     const ret = {
-      manifest: manifest,
-      media: media,
-      drm: drm,
+      manifest,
+      media,
+      drm,
+      hardwareResolution,
     };
 
     const plugins = shaka.Player.supportPlugins_;
@@ -1301,6 +1383,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.adManager_.onAssetUnload();
       }
 
+      if (this.preloadDueAdManager_ && !keepAdManager) {
+        this.preloadDueAdManager_.destroy();
+        this.preloadDueAdManager_ = null;
+      }
+
+      if (!keepAdManager) {
+        this.preloadDueAdManagerTimer_.stop();
+      }
+
       if (this.cmsdManager_) {
         this.cmsdManager_.reset();
       }
@@ -1332,6 +1423,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.drmEngine_ = null;
       }
 
+      if (this.preloadNextUrl_ &&
+          this.assetUri_ != this.preloadNextUrl_.getAssetUri()) {
+        if (!this.preloadNextUrl_.isDestroyed()) {
+          this.preloadNextUrl_.destroy();
+        }
+        this.preloadNextUrl_ = null;
+      }
+
       this.assetUri_ = null;
       this.mimeType_ = null;
       this.bufferObserver_ = null;
@@ -1351,6 +1450,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         }
       }
 
+      // On some devices, cached MediaKeySystemAccess objects may corrupt
+      // 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) {
+        shaka.util.StreamUtils.clearDecodingConfigCache();
+        shaka.media.DrmEngine.clearMediaKeySystemAccessMap();
+      }
+
       this.manifest_ = null;
       this.stats_ = new shaka.util.Stats(); // Replace with a clean object.
       this.lastTextFactory_ = null;
@@ -1426,6 +1534,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (this.assetUri_) {
+      // Note: This is used to avoid the destruction of the nextUrl
+      // preloadManager that can be the current one.
+      this.assetUri_ = assetUri;
       await this.unload(/* initializeMediaSource= */ false);
     }
 
@@ -1627,6 +1738,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         // properly destroyed or released.
         await preloadManager.destroy();
       }
+      this.preloadNextUrl_ = null;
     }
   }
 
@@ -1664,6 +1776,34 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   async unloadAndSavePreload(
       initializeMediaSource = true, keepAdManager = false) {
+    const preloadManager = await this.savePreload_();
+    await this.unload(initializeMediaSource, keepAdManager);
+    return preloadManager;
+  }
+
+  /**
+   * Detach the player from the current media element, if any, and returns a
+   * PreloadManager that contains the loaded manifest of that asset, if any.
+   * Allows for the asset to be re-loaded by this player faster, in the future.
+   * When in src= mode, this detach but does not make a PreloadManager.
+   * Leaves the player in a state where it cannot play media, until it has been
+   * attached to something else.
+   *
+   * @param {boolean=} keepAdManager
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   * @export
+   */
+  async detachAndSavePreload(keepAdManager = false) {
+    const preloadManager = await this.savePreload_();
+    await this.detach(keepAdManager);
+    return preloadManager;
+  }
+
+  /**
+   * @return {!Promise.<?shaka.media.PreloadManager>}
+   * @private
+   */
+  async savePreload_() {
     let preloadManager = null;
     if (this.manifest_ && this.parser_ && this.parserFactory_ &&
         this.assetUri_) {
@@ -1698,7 +1838,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.abrManager_ = null;
       this.abrManagerFactory_ = null;
     }
-    await this.unload(initializeMediaSource, keepAdManager);
     return preloadManager;
   }
 
@@ -2376,6 +2515,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.loadEventManager_.listen(
           mediaElement, 'timeupdate', onVideoProgress);
       this.onVideoProgress_();
+      if (this.manifest_.nextUrl) {
+        if (this.config_.streaming.preloadNextUrlWindow > 0) {
+          const onTimeUpdate = async () => {
+            const timeToEnd = this.video_.duration - this.video_.currentTime;
+            if (!isNaN(timeToEnd)) {
+              if (timeToEnd <= this.config_.streaming.preloadNextUrlWindow) {
+                this.loadEventManager_.unlisten(
+                    mediaElement, 'timeupdate', onTimeUpdate);
+                goog.asserts.assert(this.manifest_.nextUrl,
+                    'this.manifest_.nextUrl should be valid.');
+                this.preloadNextUrl_ =
+                    await this.preload(this.manifest_.nextUrl);
+              }
+            }
+          };
+          this.loadEventManager_.listen(
+              mediaElement, 'timeupdate', onTimeUpdate);
+        }
+        this.loadEventManager_.listen(mediaElement, 'ended', () => {
+          this.load(this.preloadNextUrl_ || this.manifest_.nextUrl);
+        });
+      }
     }
 
     if (this.adManager_) {
@@ -3413,10 +3574,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
-    // rebufferingGoal and segmentPrefetchLimit and baseDelay are not
-    // specified, set inaccurateManifestTolerance to 0 and rebufferingGoal
-    // to 0.01 and segmentPrefetchLimit to 2 and updateIntervalSeconds to
-    // 0.1 and baseDelay to 100 by default for low latency streaming.
+    // rebufferingGoal and segmentPrefetchLimit and baseDelay and
+    // autoCorrectDrift and maxDisabledTime are not specified, set
+    // inaccurateManifestTolerance to 0 and rebufferingGoal to 0.01 and
+    // segmentPrefetchLimit to 2 and updateIntervalSeconds to 0.1 and and
+    // baseDelay to 100 and autoCorrectDrift to false and maxDisabledTime
+    // to 1 by default for low latency streaming.
     if (config['streaming'] && config['streaming']['lowLatencyMode']) {
       if (config['streaming']['inaccurateManifestTolerance'] == undefined) {
         config['streaming']['inaccurateManifestTolerance'] = 0;
@@ -3430,6 +3593,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       if (config['streaming']['updateIntervalSeconds'] == undefined) {
         config['streaming']['updateIntervalSeconds'] = 0.1;
       }
+      if (config['streaming']['maxDisabledTime'] == undefined) {
+        config['streaming']['maxDisabledTime'] = 1;
+      }
       if (config['streaming']['retryParameters'] == undefined) {
         config['streaming']['retryParameters'] = {};
       }
@@ -3439,6 +3605,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       if (config['manifest'] == undefined) {
         config['manifest'] = {};
       }
+      if (config['manifest']['dash'] == undefined) {
+        config['manifest']['dash'] = {};
+      }
+      if (config['manifest']['dash']['autoCorrectDrift'] == undefined) {
+        config['manifest']['dash']['autoCorrectDrift'] = false;
+      }
       if (config['manifest']['retryParameters'] == undefined) {
         config['manifest']['retryParameters'] = {};
       }
@@ -3513,6 +3685,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
     }
     if (this.networkingEngine_) {
+      this.networkingEngine_.setForceHTTP(this.config_.streaming.forceHTTP);
       this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
     }
 
@@ -3600,6 +3773,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return ret;
   }
 
+  /**
+   * Return a copy of the current non default configuration.  Modifications of
+   * the returned value will not affect the Player's active configuration.
+   * You must call <code>player.configure()</code> to make changes.
+   *
+   * @return {!Object}
+   * @export
+   */
+  getNonDefaultConfiguration() {
+    goog.asserts.assert(this.config_, 'Config must not be null!');
+
+    const ret = this.defaultConfig_();
+    shaka.util.PlayerConfiguration.mergeConfigObjects(
+        ret, this.config_, this.defaultConfig_());
+    return shaka.util.ConfigUtils.getDifferenceFromConfigObjects(
+        this.config_, this.defaultConfig_());
+  }
+
   /**
    * Return a reference to the current configuration. Modifications to the
    * returned value will affect the Player's active configuration. This method
@@ -5734,6 +5925,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         error.code == shaka.util.Error.Code.HTTP_ERROR) {
       // These errors can be near-instant, so delay a bit before retrying.
       retryDelaySeconds = 1;
+      if (this.config_.streaming.lowLatencyMode) {
+        retryDelaySeconds = 0.1;
+      }
     } else if (error.code == shaka.util.Error.Code.TIMEOUT) {
       // We already waited for a timeout, so retry quickly.
       retryDelaySeconds = 0.1;
@@ -6027,8 +6221,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // 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;
+        liveSyncMaxLatency = this.config_.streaming.liveSyncMaxLatency;
+        if (this.manifest_.serviceDescription.targetLatency != null) {
+          liveSyncMaxLatency =
+              this.manifest_.serviceDescription.targetLatency +
+              this.config_.streaming.liveSyncTargetLatencyTolerance;
+        } else if (this.manifest_.serviceDescription.maxLatency != null) {
+          liveSyncMaxLatency = this.manifest_.serviceDescription.maxLatency;
+        }
         liveSyncPlaybackRate =
           this.manifest_.serviceDescription.maxPlaybackRate ||
           this.config_.streaming.liveSyncPlaybackRate;
@@ -6044,8 +6244,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // serviceDescription must override if it is defined in the MPD and
       // liveSync configuration is not set.
       if (this.manifest_ && this.manifest_.serviceDescription) {
-        liveSyncMinLatency = this.manifest_.serviceDescription.minLatency ||
-          this.config_.streaming.liveSyncMinLatency;
+        liveSyncMinLatency = this.config_.streaming.liveSyncMinLatency;
+        if (this.manifest_.serviceDescription.targetLatency != null) {
+          liveSyncMinLatency =
+              this.manifest_.serviceDescription.targetLatency -
+              this.config_.streaming.liveSyncTargetLatencyTolerance;
+        } else if (this.manifest_.serviceDescription.minLatency != null) {
+          liveSyncMinLatency = this.manifest_.serviceDescription.minLatency;
+        }
         liveSyncMinPlaybackRate =
           this.manifest_.serviceDescription.minPlaybackRate ||
           this.config_.streaming.liveSyncMinPlaybackRate;
@@ -7240,7 +7446,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.8.10' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.9.1' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -8,6 +8,7 @@ goog.provide('shaka.polyfill.MediaCapabilities');
 
 goog.require('shaka.log');
 goog.require('shaka.media.Capabilities');
+goog.require('shaka.media.DrmEngine');
 goog.require('shaka.polyfill');
 goog.require('shaka.util.Platform');
 
@@ -276,25 +277,22 @@ shaka.polyfill.MediaCapabilities = class {
       mediaKeySystemConfig.videoCapabilities = videoCapabilities;
     }
 
-    const cacheKey = shaka.polyfill.MediaCapabilities
-        .generateKeySystemCacheKey_(
-            videoConfig ? videoConfig.contentType : '',
-            audioConfig ? audioConfig.contentType : '',
-            mcapKeySystemConfig.keySystem);
+    const videoCodec = videoConfig ? videoConfig.contentType : '';
+    const audioCodec = audioConfig ? audioConfig.contentType : '';
+    const keySystem = mcapKeySystemConfig.keySystem;
 
     /** @type {MediaKeySystemAccess} */
     let keySystemAccess = null;
     try {
-      if (cacheKey in shaka.polyfill.MediaCapabilities
-          .memoizedMediaKeySystemAccessRequests_) {
-        keySystemAccess = shaka.polyfill.MediaCapabilities
-            .memoizedMediaKeySystemAccessRequests_[cacheKey];
+      if (shaka.media.DrmEngine.hasMediaKeySystemAccess(
+          videoCodec, audioCodec, keySystem)) {
+        keySystemAccess = shaka.media.DrmEngine.getMediaKeySystemAccess(
+            videoCodec, audioCodec, keySystem);
       } else {
         keySystemAccess = await navigator.requestMediaKeySystemAccess(
             mcapKeySystemConfig.keySystem, [mediaKeySystemConfig]);
-        shaka.polyfill.MediaCapabilities
-            .memoizedMediaKeySystemAccessRequests_[cacheKey] =
-              keySystemAccess;
+        shaka.media.DrmEngine.setMediaKeySystemAccess(
+            videoCodec, audioCodec, keySystem, keySystemAccess);
       }
     } catch (e) {
       shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
@@ -346,19 +344,6 @@ shaka.polyfill.MediaCapabilities = class {
     }
     return result;
   }
-
-  /**
-   * A method for generating a key for the MediaKeySystemAccessRequests cache.
-   *
-   * @param {!string} videoCodec
-   * @param {!string} audioCodec
-   * @param {!string} keySystem
-   * @return {!string}
-   * @private
-   */
-  static generateKeySystemCacheKey_(videoCodec, audioCodec, keySystem) {
-    return `${videoCodec}#${audioCodec}#${keySystem}`;
-  }
 };
 
 /**
@@ -371,16 +356,6 @@ shaka.polyfill.MediaCapabilities = class {
  */
 shaka.polyfill.MediaCapabilities.originalMcap = null;
 
-/**
- * A cache that stores the MediaKeySystemAccess result of calling
- * `navigator.requestMediaKeySystemAccess` by a key combination of
- * video/audio codec and key system string.
- *
- * @type {(Object<(!string), (!MediaKeySystemAccess)>)}
- * @export
- */
-shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
-
 /**
  * A cache that stores the canDisplayType result of calling
  * `cast.__platform__.canDisplayType`.

package/lib/transmuxer/aac_transmuxer.js

@@ -141,7 +141,8 @@ shaka.transmuxer.AacTransmuxer = class {
       return Promise.reject(new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
-          shaka.util.Error.Code.TRANSMUXING_FAILED));
+          shaka.util.Error.Code.TRANSMUXING_FAILED,
+          reference ? reference.getUris()[0] : null));
     }
     stream.audioSamplingRate = info.sampleRate;
     stream.channelsCount = info.channelCount;
@@ -155,7 +156,8 @@ shaka.transmuxer.AacTransmuxer = class {
         return Promise.reject(new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MEDIA,
-            shaka.util.Error.Code.TRANSMUXING_FAILED));
+            shaka.util.Error.Code.TRANSMUXING_FAILED,
+            reference ? reference.getUris()[0] : null));
       }
       const length = header.headerLength + header.frameLength;
       if (offset + length <= uint8ArrayData.length) {

package/lib/transmuxer/ac3_transmuxer.js

@@ -144,7 +144,8 @@ shaka.transmuxer.Ac3Transmuxer = class {
         return Promise.reject(new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MEDIA,
-            shaka.util.Error.Code.TRANSMUXING_FAILED));
+            shaka.util.Error.Code.TRANSMUXING_FAILED,
+            reference ? reference.getUris()[0] : null));
       }
       stream.audioSamplingRate = frame.sampleRate;
       stream.channelsCount = frame.channelCount;