shaka-player 4.8.10 → 4.9.1

package/lib/media/drm_engine.js

@@ -21,6 +21,7 @@ goog.require('shaka.util.Lazy');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MapUtils');
 goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.Pssh');
 goog.require('shaka.util.PublicPromise');
@@ -1492,6 +1493,13 @@ shaka.media.DrmEngine = class {
       request.initData = metadata.initData;
       request.initDataType = metadata.initDataType;
     }
+    if (advancedConfig && advancedConfig.headers) {
+      // Add these to the existing headers.  Do not clobber them!
+      // For PlayReady, there will already be headers in the request.
+      for (const header in advancedConfig.headers) {
+        request.headers[header] = advancedConfig.headers[header];
+      }
+    }
     // NOTE: allowCrossSiteCredentials can be set in a request filter.
 
     if (shaka.media.DrmEngine.isPlayReadyKeySystem(
@@ -1801,33 +1809,200 @@ shaka.media.DrmEngine = class {
       'com.widevine.alpha',
       'com.microsoft.playready',
       'com.microsoft.playready.recommendation',
+      'com.chromecast.playready',
       'com.apple.fps.1_0',
       'com.apple.fps',
     ];
 
+    const widevineRobustness = [
+      'SW_SECURE_CRYPTO',
+      'SW_SECURE_DECODE',
+      'HW_SECURE_CRYPTO',
+      'HW_SECURE_DECODE',
+      'HW_SECURE_ALL',
+    ];
+
+    const playreadyRobustness = [
+      '150',
+      '2000',
+      '3000',
+    ];
+
+    const testRobustness = {
+      'com.widevine.alpha': widevineRobustness,
+      'com.microsoft.playready': playreadyRobustness,
+      'com.microsoft.playready.recommendation': playreadyRobustness,
+      'com.chromecast.playready': playreadyRobustness,
+    };
+
     const basicVideoCapabilities = [
       {contentType: 'video/mp4; codecs="avc1.42E01E"'},
       {contentType: 'video/webm; codecs="vp8"'},
     ];
 
-    const basicConfig = {
-      initDataTypes: ['cenc'],
-      videoCapabilities: basicVideoCapabilities,
-    };
-    const offlineConfig = {
+    const basicAudioCapabilities = [
+      {contentType: 'audio/mp4; codecs="mp4a.40.2"'},
+      {contentType: 'audio/webm; codecs="opus"'},
+    ];
+
+    const basicConfigTemplate = {
       videoCapabilities: basicVideoCapabilities,
-      persistentState: 'required',
-      sessionTypes: ['persistent-license'],
+      audioCapabilities: basicAudioCapabilities,
+      initDataTypes: ['cenc', 'sinf', 'skd', 'keyids'],
     };
 
-    // Try the offline config first, then fall back to the basic config.
-    const configs = [offlineConfig, basicConfig];
+    const testEncryptionSchemes = [
+      null,
+      'cenc',
+      'cbcs',
+      'cbcs-1-9',
+    ];
 
     /** @type {!Map.<string, ?shaka.extern.DrmSupportType>} */
     const support = new Map();
 
-    const testSystem = async (keySystem) => {
+    /**
+     * @param {string} keySystem
+     * @param {MediaKeySystemAccess} access
+     * @return {!Promise}
+     */
+    const processMediaKeySystemAccess = async (keySystem, access) => {
+      try {
+        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
+        // support structure.  If a previous test succeeded, we won't overwrite
+        // any of the results.
+        return;
+      }
+
+      // If sessionTypes is missing, assume no support for persistent-license.
+      const sessionTypes = access.getConfiguration().sessionTypes;
+      let persistentState = sessionTypes ?
+          sessionTypes.includes('persistent-license') : false;
+
+      // Tizen 3.0 doesn't support persistent licenses, but reports that it
+      // does.  It doesn't fail until you call update() with a license
+      // response, which is way too late.
+      // This is a work-around for #894.
+      if (shaka.util.Platform.isTizen3()) {
+        persistentState = false;
+      }
+
+      const videoCapabilities = access.getConfiguration().videoCapabilities;
+      const audioCapabilities = access.getConfiguration().audioCapabilities;
+
+      let supportValue = {
+        persistentState,
+        encryptionSchemes: [],
+        videoRobustnessLevels: [],
+        audioRobustnessLevels: [],
+      };
+      if (support.has(keySystem) && support.get(keySystem)) {
+        // Update the existing non-null value.
+        supportValue = support.get(keySystem);
+      } else {
+        // Set a new one.
+        support.set(keySystem, supportValue);
+      }
+
+      // If the returned config doesn't mention encryptionScheme, the field
+      // is not supported.  If installed, our polyfills should make sure this
+      // doesn't happen.
+      const returnedScheme = videoCapabilities[0].encryptionScheme;
+      if (returnedScheme &&
+          !supportValue.encryptionSchemes.includes(returnedScheme)) {
+        supportValue.encryptionSchemes.push(returnedScheme);
+      }
+
+      const videoRobustness = videoCapabilities[0].robustness;
+      if (videoRobustness &&
+          !supportValue.videoRobustnessLevels.includes(videoRobustness)) {
+        supportValue.videoRobustnessLevels.push(videoRobustness);
+      }
+
+      const audioRobustness = audioCapabilities[0].robustness;
+      if (audioRobustness &&
+          !supportValue.audioRobustnessLevels.includes(audioRobustness)) {
+        supportValue.audioRobustnessLevels.push(audioRobustness);
+      }
+    };
+
+    const testSystemEme = async (keySystem, encryptionScheme,
+        videoRobustness, audioRobustness) => {
+      try {
+        const basicConfig =
+            shaka.util.ObjectUtils.cloneObject(basicConfigTemplate);
+        for (const cap of basicConfig.videoCapabilities) {
+          cap.encryptionScheme = encryptionScheme;
+          cap.robustness = videoRobustness;
+        }
+        for (const cap of basicConfig.audioCapabilities) {
+          cap.encryptionScheme = encryptionScheme;
+          cap.robustness = audioRobustness;
+        }
+
+        const offlineConfig = shaka.util.ObjectUtils.cloneObject(basicConfig);
+        offlineConfig.persistentState = 'required';
+        offlineConfig.sessionTypes = ['persistent-license'];
+
+        const configs = [offlineConfig, basicConfig];
+
+        const access = await navigator.requestMediaKeySystemAccess(
+            keySystem, configs);
+        await processMediaKeySystemAccess(keySystem, access);
+      } catch (error) {}  // Ignore errors.
+    };
+
+    const testSystemMcap = async (keySystem, encryptionScheme,
+        videoRobustness, audioRobustness) => {
       try {
+        const decodingConfig = {
+          type: 'media-source',
+          video: {
+            contentType: basicVideoCapabilities[0].contentType,
+            width: 640,
+            height: 480,
+            bitrate: 1,
+            framerate: 1,
+          },
+          audio: {
+            contentType: basicAudioCapabilities[0].contentType,
+            channels: 2,
+            bitrate: 1,
+            samplerate: 1,
+          },
+          keySystemConfiguration: {
+            keySystem,
+            video: {
+              encryptionScheme,
+              robustness: videoRobustness,
+            },
+            audio: {
+              encryptionScheme,
+              robustness: audioRobustness,
+            },
+          },
+        };
+
+        const decodingInfo =
+            await navigator.mediaCapabilities.decodingInfo(decodingConfig);
+
+        const access = decodingInfo.keySystemAccess;
+        await processMediaKeySystemAccess(keySystem, access);
+      } catch (error) {}  // Ignore errors.
+    };
+
+    // Initialize the support structure for each key system.
+    for (const keySystem of testKeySystems) {
+      support.set(keySystem, null);
+    }
+
+    // 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
@@ -1835,40 +2010,22 @@ shaka.media.DrmEngine = class {
         // Safari bug: https://bugs.webkit.org/show_bug.cgi?id=231006
         if (keySystem === 'org.w3.clearkey' &&
             shaka.util.Platform.isSafari()) {
-          throw new Error('Unsupported keySystem');
-        }
-
-        const access = await navigator.requestMediaKeySystemAccess(
-            keySystem, configs);
-
-        // Edge doesn't return supported session types, but current versions
-        // do not support persistent-license.  If sessionTypes is missing,
-        // assume no support for persistent-license.
-        // TODO: Polyfill Edge to return known supported session types.
-        // Edge bug: https://bit.ly/2IeKzho
-        const sessionTypes = access.getConfiguration().sessionTypes;
-        let persistentState = sessionTypes ?
-            sessionTypes.includes('persistent-license') : false;
-
-        // Tizen 3.0 doesn't support persistent licenses, but reports that it
-        // does.  It doesn't fail until you call update() with a license
-        // response, which is way too late.
-        // This is a work-around for #894.
-        if (shaka.util.Platform.isTizen3()) {
-          persistentState = false;
+          continue;
         }
+        tests.push(testSystemEme(keySystem, encryptionScheme, '', ''));
+        tests.push(testSystemMcap(keySystem, encryptionScheme, '', ''));
+      }
+    }
 
-        support.set(keySystem, {persistentState: persistentState});
-        await access.createMediaKeys();
-      } catch (e) {
-        // Either the request failed or createMediaKeys failed.
-        // Either way, write null to the support object.
-        support.set(keySystem, null);
+    for (const keySystem of testKeySystems) {
+      for (const robustness of (testRobustness[keySystem] || [])) {
+        tests.push(testSystemEme(keySystem, null, robustness, ''));
+        tests.push(testSystemEme(keySystem, null, '', robustness));
+        tests.push(testSystemMcap(keySystem, null, robustness, ''));
+        tests.push(testSystemMcap(keySystem, null, '', robustness));
       }
-    };
+    }
 
-    // Test each key system.
-    const tests = testKeySystems.map((keySystem) => testSystem(keySystem));
     await Promise.all(tests);
     return shaka.util.MapUtils.asObject(support);
   }
@@ -2562,6 +2719,73 @@ shaka.media.DrmEngine = class {
     this.newInitData('cenc', combinedData);
     return this.allSessionsLoaded_;
   }
+
+  /**
+   * 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}`;
+  }
+
+  /**
+   * Check does MediaKeySystemAccess cache contains something for following
+   * attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @return {boolean}
+   */
+  static hasMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
+    const DrmEngine = shaka.media.DrmEngine;
+    const key = DrmEngine.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmEngine.memoizedMediaKeySystemAccessRequests_.has(key);
+  }
+
+  /**
+   * Get MediaKeySystemAccess object for following attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @return {?MediaKeySystemAccess}
+   */
+  static getMediaKeySystemAccess(videoCodec, audioCodec, keySystem) {
+    const DrmEngine = shaka.media.DrmEngine;
+    const key = DrmEngine.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmEngine.memoizedMediaKeySystemAccessRequests_.get(key) || null;
+  }
+
+  /**
+   * Store MediaKeySystemAccess object associated with specified attributes.
+   *
+   * @param {string} videoCodec
+   * @param {string} audioCodec
+   * @param {string} keySystem
+   * @param {!MediaKeySystemAccess} mksa
+   */
+  static setMediaKeySystemAccess(videoCodec, audioCodec, keySystem, mksa) {
+    const DrmEngine = shaka.media.DrmEngine;
+    const key = DrmEngine.generateKeySystemCacheKey_(
+        videoCodec, audioCodec, keySystem);
+    return DrmEngine.memoizedMediaKeySystemAccessRequests_.set(key, mksa);
+  }
+
+  /**
+   * Clears underlying cache.
+   */
+  static clearMediaKeySystemAccessMap() {
+    const DrmEngine = shaka.media.DrmEngine;
+    DrmEngine.memoizedMediaKeySystemAccessRequests_.clear();
+  }
 };
 
 
@@ -2655,3 +2879,13 @@ shaka.media.DrmEngine.KEY_STATUS_BATCH_TIME = 0.5;
  */
 shaka.media.DrmEngine.DUMMY_KEY_ID = new shaka.util.Lazy(
     () => shaka.util.BufferUtils.toArrayBuffer(new Uint8Array([0])));
+
+
+/**
+ * A cache that stores the MediaKeySystemAccess result of calling
+ * `navigator.requestMediaKeySystemAccess` by a key combination of
+ * video/audio codec and key system string.
+ *
+ * @private {!Map<string, !MediaKeySystemAccess>}
+ */
+shaka.media.DrmEngine.memoizedMediaKeySystemAccessRequests_ = new Map();

package/lib/media/manifest_filterer.js

@@ -19,7 +19,7 @@ goog.require('shaka.util.Error');
 shaka.media.ManifestFilterer = class {
   /**
    * @param {?shaka.extern.PlayerConfiguration} config
-   * @param {{width: number, height: number}} maxHwRes
+   * @param {shaka.extern.Resolution} maxHwRes
    * @param {?shaka.media.DrmEngine} drmEngine
    */
   constructor(config, maxHwRes, drmEngine) {
@@ -28,7 +28,7 @@ shaka.media.ManifestFilterer = class {
     /** @private {!shaka.extern.PlayerConfiguration} */
     this.config_ = config;
 
-    /** @private {{width: number, height: number}} */
+    /** @private {shaka.extern.Resolution} */
     this.maxHwRes_ = maxHwRes;
 
     /** @private {?shaka.media.DrmEngine} drmEngine */

package/lib/media/media_source_engine.js

@@ -569,7 +569,8 @@ shaka.media.MediaSourceEngine = class {
             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
             exception,
             'The mediaSource_ status was ' + this.mediaSource_.readyState +
-            ' expected \'open\'');
+            ' expected \'open\'',
+            null);
       }
 
       if (this.sequenceMode_) {
@@ -935,10 +936,12 @@ shaka.media.MediaSourceEngine = class {
           if (this.attemptTimestampOffsetCalculation_) {
             this.enqueueOperation_(
                 contentType,
-                () => this.abort_(contentType));
+                () => this.abort_(contentType),
+                null);
             this.enqueueOperation_(
                 contentType,
-                () => this.setTimestampOffset_(contentType, timestampOffset));
+                () => this.setTimestampOffset_(contentType, timestampOffset),
+                null);
           }
         }
         // Timestamps can only be reliably extracted from video, not audio.
@@ -983,7 +986,8 @@ shaka.media.MediaSourceEngine = class {
     }
 
     data = this.workAroundBrokenPlatforms_(
-        data, reference ? reference.startTime : null, contentType);
+        data, reference ? reference.startTime : null, contentType,
+        reference ? reference.getUris()[0] : null);
 
     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
       // In sequence mode, for non-text streams, if we just cleared the buffer
@@ -995,10 +999,14 @@ shaka.media.MediaSourceEngine = class {
         // extended during unbuffered seeks or automatic adaptations; it is
         // possible for the append state to be PARSING_MEDIA_SEGMENT from the
         // previous SourceBuffer#appendBuffer() call.
-        this.enqueueOperation_(contentType, () => this.abort_(contentType));
         this.enqueueOperation_(
             contentType,
-            () => this.setTimestampOffset_(contentType, timestampOffset));
+            () => this.abort_(contentType),
+            null);
+        this.enqueueOperation_(
+            contentType,
+            () => this.setTimestampOffset_(contentType, timestampOffset),
+            null);
       }
     }
 
@@ -1009,7 +1017,7 @@ shaka.media.MediaSourceEngine = class {
         bufferedBefore = this.getBuffered_(contentType);
       }
       this.append_(contentType, data, timestampOffset);
-    });
+    }, reference ? reference.getUris()[0] : null);
 
     if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
       const bufferedAfter = this.getBuffered_(contentType);
@@ -1067,11 +1075,13 @@ shaka.media.MediaSourceEngine = class {
     } else {
       await this.enqueueOperation_(
           contentType,
-          () => this.remove_(contentType, startTime, endTime));
+          () => this.remove_(contentType, startTime, endTime),
+          null);
       if (this.needSplitMuxedContent_) {
         await this.enqueueOperation_(
             ContentType.AUDIO,
-            () => this.remove_(ContentType.AUDIO, startTime, endTime));
+            () => this.remove_(ContentType.AUDIO, startTime, endTime),
+            null);
       }
     }
   }
@@ -1093,12 +1103,14 @@ shaka.media.MediaSourceEngine = class {
       // Note that not all platforms allow clearing to Infinity.
       await this.enqueueOperation_(
           contentType,
-          () => this.remove_(contentType, 0, this.mediaSource_.duration));
+          () => this.remove_(contentType, 0, this.mediaSource_.duration),
+          null);
       if (this.needSplitMuxedContent_) {
         await this.enqueueOperation_(
             ContentType.AUDIO,
             () => this.remove_(
-                ContentType.AUDIO, 0, this.mediaSource_.duration));
+                ContentType.AUDIO, 0, this.mediaSource_.duration),
+            null);
       }
     }
   }
@@ -1129,11 +1141,13 @@ shaka.media.MediaSourceEngine = class {
     }
     await this.enqueueOperation_(
         contentType,
-        () => this.flush_(contentType));
+        () => this.flush_(contentType),
+        null);
     if (this.needSplitMuxedContent_) {
       await this.enqueueOperation_(
           ContentType.AUDIO,
-          () => this.flush_(ContentType.AUDIO));
+          () => this.flush_(ContentType.AUDIO),
+          null);
     }
   }
 
@@ -1188,33 +1202,39 @@ shaka.media.MediaSourceEngine = class {
       // set it.
       operations.push(this.enqueueOperation_(
           contentType,
-          () => this.abort_(contentType)));
+          () => this.abort_(contentType),
+          null));
       if (this.needSplitMuxedContent_) {
         operations.push(this.enqueueOperation_(
             ContentType.AUDIO,
-            () => this.abort_(ContentType.AUDIO)));
+            () => this.abort_(ContentType.AUDIO),
+            null));
       }
     }
     if (!ignoreTimestampOffset) {
       operations.push(this.enqueueOperation_(
           contentType,
-          () => this.setTimestampOffset_(contentType, timestampOffset)));
+          () => this.setTimestampOffset_(contentType, timestampOffset),
+          null));
       if (this.needSplitMuxedContent_) {
         operations.push(this.enqueueOperation_(
             ContentType.AUDIO,
             () => this.setTimestampOffset_(
-                ContentType.AUDIO, timestampOffset)));
+                ContentType.AUDIO, timestampOffset),
+            null));
       }
     }
     operations.push(this.enqueueOperation_(
         contentType,
         () => this.setAppendWindow_(
-            contentType, appendWindowStart, appendWindowEnd)));
+            contentType, appendWindowStart, appendWindowEnd),
+        null));
     if (this.needSplitMuxedContent_) {
       operations.push(this.enqueueOperation_(
           ContentType.AUDIO,
           () => this.setAppendWindow_(
-              ContentType.AUDIO, appendWindowStart, appendWindowEnd)));
+              ContentType.AUDIO, appendWindowStart, appendWindowEnd),
+          null));
     }
 
     await Promise.all(operations);
@@ -1251,19 +1271,23 @@ shaka.media.MediaSourceEngine = class {
     // set it.
     this.enqueueOperation_(
         contentType,
-        () => this.abort_(contentType));
+        () => this.abort_(contentType),
+        null);
     if (this.needSplitMuxedContent_) {
       this.enqueueOperation_(
           ContentType.AUDIO,
-          () => this.abort_(ContentType.AUDIO));
+          () => this.abort_(ContentType.AUDIO),
+          null);
     }
     await this.enqueueOperation_(
         contentType,
-        () => this.setTimestampOffset_(contentType, timestampOffset));
+        () => this.setTimestampOffset_(contentType, timestampOffset),
+        null);
     if (this.needSplitMuxedContent_) {
       await this.enqueueOperation_(
           ContentType.AUDIO,
-          () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset));
+          () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset),
+          null);
     }
   }
 
@@ -1306,6 +1330,7 @@ shaka.media.MediaSourceEngine = class {
           const dummyOperation = {
             start: () => {},
             p: new shaka.util.PublicPromise(),
+            uri: null,
           };
           this.queues_[contentType].unshift(dummyOperation);
         }
@@ -1465,7 +1490,7 @@ shaka.media.MediaSourceEngine = class {
         shaka.util.Error.Severity.CRITICAL,
         shaka.util.Error.Category.MEDIA,
         shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
-        code));
+        code, operation.uri));
     // Do not pop from queue.  An 'updateend' event will fire next, and to
     // avoid synchronizing these two event handlers, we will allow that one to
     // pop from the queue as normal.  Note that because the operation has
@@ -1497,14 +1522,16 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {function()} start
+   * @param {?string} uri
    * @return {!Promise}
    * @private
    */
-  enqueueOperation_(contentType, start) {
+  enqueueOperation_(contentType, start, uri) {
     this.destroyer_.ensureNotDestroyed();
     const operation = {
       start: start,
       p: new shaka.util.PublicPromise(),
+      uri,
     };
     this.queues_[contentType].push(operation);
 
@@ -1536,6 +1563,7 @@ shaka.media.MediaSourceEngine = class {
       const operation = {
         start: () => ready.resolve(),
         p: ready,
+        uri: null,
       };
 
       this.queues_[contentType].push(operation);
@@ -1593,7 +1621,8 @@ shaka.media.MediaSourceEngine = class {
           shaka.util.Error.Category.MEDIA,
           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
           exception,
-          this.video_.error || 'No error in the media element');
+          this.video_.error || 'No error in the media element',
+          null);
     } finally {
       // Unblock the queues.
       for (const contentType in this.sourceBuffers_) {
@@ -1637,7 +1666,8 @@ shaka.media.MediaSourceEngine = class {
               shaka.util.Error.Category.MEDIA,
               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
               exception,
-              this.video_.error || 'No error in the media element'));
+              this.video_.error || 'No error in the media element',
+              next.uri));
         }
         this.popFromQueue_(contentType);
       }
@@ -1684,10 +1714,11 @@ shaka.media.MediaSourceEngine = class {
    * @param {!BufferSource} segment
    * @param {?number} startTime
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {?string} uri
    * @return {!BufferSource}
    * @private
    */
-  workAroundBrokenPlatforms_(segment, startTime, contentType) {
+  workAroundBrokenPlatforms_(segment, startTime, contentType, uri) {
     const isInitSegment = startTime == null;
     const encryptionExpected = this.expectedEncryption_[contentType];
 
@@ -1708,7 +1739,7 @@ shaka.media.MediaSourceEngine = class {
         shaka.util.MimeUtils.getContainerType(
             this.sourceBufferTypes_[contentType]) == 'mp4') {
       shaka.log.debug('Forcing fake encryption information in init segment.');
-      segment = shaka.media.ContentWorkarounds.fakeEncryption(segment);
+      segment = shaka.media.ContentWorkarounds.fakeEncryption(segment, uri);
     }
 
     return segment;
@@ -1761,7 +1792,8 @@ shaka.media.MediaSourceEngine = class {
   changeType(contentType, mimeType, transmuxer) {
     return this.enqueueOperation_(
         contentType,
-        () => this.change_(contentType, mimeType, transmuxer));
+        () => this.change_(contentType, mimeType, transmuxer),
+        null);
   }
 
   /**
@@ -2096,7 +2128,8 @@ shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
 /**
  * @typedef {{
  *   start: function(),
- *   p: !shaka.util.PublicPromise
+ *   p: !shaka.util.PublicPromise,
+ *   uri: ?string
  * }}
  *
  * @summary An operation in queue.
@@ -2104,6 +2137,8 @@ shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  *   The function which starts the operation.
  * @property {!shaka.util.PublicPromise} p
  *   The PublicPromise which is associated with this operation.
+ * @property {?string} uri
+ *   A segment URI (if any) associated with this operation.
  */
 shaka.media.MediaSourceEngine.Operation;