shaka-player 4.7.13 → 4.8.1

package/lib/media/buffering_observer.js

@@ -28,6 +28,9 @@ shaka.media.BufferingObserver = class {
     this.thresholds_ = new Map()
         .set(State.SATISFIED, thresholdWhenSatisfied)
         .set(State.STARVING, thresholdWhenStarving);
+
+    /** @private {number} */
+    this.lastRebufferTime_ = 0;
   }
 
   /**
@@ -73,7 +76,13 @@ shaka.media.BufferingObserver = class {
     this.previousState_ = newState;
 
     // Return |true| only when the state has changed.
-    return oldState != newState;
+    const stateChanged = oldState != newState;
+
+    if (stateChanged && newState === State.SATISFIED) {
+      this.lastRebufferTime_ = Date.now();
+    }
+
+    return stateChanged;
   }
 
   /**
@@ -93,6 +102,21 @@ shaka.media.BufferingObserver = class {
   getState() {
     return this.previousState_;
   }
+
+  /**
+   * Return the last time that the state went from |STARVING| to |SATISFIED|.
+   * @return {number}
+   */
+  getLastRebufferTime() {
+    return this.lastRebufferTime_;
+  }
+
+  /**
+   * Reset the last rebuffer time to zero.
+   */
+  resetLastRebufferTime() {
+    this.lastRebufferTime_ = 0;
+  }
 };
 
 /**

package/lib/media/drm_engine.js

@@ -27,17 +27,16 @@ goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.Timer');
+goog.require('shaka.util.TXml');
 goog.require('shaka.util.Uint8ArrayUtils');
-goog.require('shaka.util.XmlUtils');
 
 
 /** @implements {shaka.util.IDestroyable} */
 shaka.media.DrmEngine = class {
   /**
    * @param {shaka.media.DrmEngine.PlayerInterface} playerInterface
-   * @param {number=} updateExpirationTime
    */
-  constructor(playerInterface, updateExpirationTime = 1) {
+  constructor(playerInterface) {
     /** @private {?shaka.media.DrmEngine.PlayerInterface} */
     this.playerInterface_ = playerInterface;
 
@@ -125,7 +124,7 @@ shaka.media.DrmEngine = class {
     /** @private {?shaka.util.Timer} */
     this.expirationTimer_ = new shaka.util.Timer(() => {
       this.pollExpiration_();
-    }).tickEvery(/* seconds= */ updateExpirationTime);
+    });
 
     // Add a catch to the Promise to avoid console logs about uncaught errors.
     const noop = () => {};
@@ -210,6 +209,10 @@ shaka.media.DrmEngine = class {
    */
   configure(config) {
     this.config_ = config;
+    if (this.expirationTimer_) {
+      this.expirationTimer_.tickEvery(
+          /* seconds= */ this.config_.updateExpirationTime);
+    }
   }
 
   /**
@@ -1215,56 +1218,8 @@ shaka.media.DrmEngine = class {
       return null;
     }
 
-    const StringUtils = shaka.util.StringUtils;
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
-    const keys = [];
-    const keyIds = [];
-
-    clearKeys.forEach((key, keyId) => {
-      let kid = keyId;
-      if (kid.length != 22) {
-        kid = Uint8ArrayUtils.toBase64(
-            Uint8ArrayUtils.fromHex(keyId), false);
-      }
-      let k = key;
-      if (k.length != 22) {
-        k = Uint8ArrayUtils.toBase64(
-            Uint8ArrayUtils.fromHex(key), false);
-      }
-      const keyObj = {
-        kty: 'oct',
-        kid: kid,
-        k: k,
-      };
-
-      keys.push(keyObj);
-      keyIds.push(keyObj.kid);
-    });
-
-    const jwkSet = {keys: keys};
-    const license = JSON.stringify(jwkSet);
-
-    // Use the keyids init data since is suggested by EME.
-    // Suggestion: https://bit.ly/2JYcNTu
-    // Format: https://www.w3.org/TR/eme-initdata-keyids/
-    const initDataStr = JSON.stringify({'kids': keyIds});
-    const initData =
-        shaka.util.BufferUtils.toUint8(StringUtils.toUTF8(initDataStr));
-    const initDatas = [{initData: initData, initDataType: 'keyids'}];
-
-    return {
-      keySystem: 'org.w3.clearkey',
-      licenseServerUri: 'data:application/json;base64,' + window.btoa(license),
-      distinctiveIdentifierRequired: false,
-      persistentStateRequired: false,
-      audioRobustness: '',
-      videoRobustness: '',
-      serverCertificate: null,
-      serverCertificateUri: '',
-      sessionType: '',
-      initData: initDatas,
-      keyIds: new Set(keyIds),
-    };
+    const ManifestParserUtils = shaka.util.ManifestParserUtils;
+    return ManifestParserUtils.createDrmInfoFromClearKeys(clearKeys);
   }
 
   /**
@@ -1551,6 +1506,9 @@ shaka.media.DrmEngine = class {
       const req = this.playerInterface_.netEngine.request(requestType, request);
       response = await req.promise;
     } catch (error) {
+      if (this.destroyer_.destroyed()) {
+        return;
+      }
       // Request failed!
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong NetworkingEngine error type!');
@@ -1559,9 +1517,20 @@ shaka.media.DrmEngine = class {
           shaka.util.Error.Category.DRM,
           shaka.util.Error.Code.LICENSE_REQUEST_FAILED,
           error);
-      this.onError_(shakaErr);
-      if (metadata && metadata.updatePromise) {
-        metadata.updatePromise.reject(shakaErr);
+      if (this.activeSessions_.size == 1) {
+        this.onError_(shakaErr);
+        if (metadata && metadata.updatePromise) {
+          metadata.updatePromise.reject(shakaErr);
+        }
+      } else {
+        if (metadata && metadata.updatePromise) {
+          metadata.updatePromise.reject(shakaErr);
+        }
+        this.activeSessions_.delete(session);
+        if (this.areAllSessionsLoaded_()) {
+          this.allSessionsLoaded_.resolve();
+          this.keyStatusTimer_.tickAfter(/* seconds= */ 0.1);
+        }
       }
       return;
     }
@@ -1637,6 +1606,7 @@ shaka.media.DrmEngine = class {
     //     </HttpHeaders>
     //   </LicenseAcquisition>
     // </PlayReadyKeyMessage>
+    const TXml = shaka.util.TXml;
 
     const xml = shaka.util.StringUtils.fromUTF16(
         request.body, /* littleEndian= */ true, /* noThrow= */ true);
@@ -1650,24 +1620,28 @@ shaka.media.DrmEngine = class {
       return;
     }
     shaka.log.debug('Unwrapping PlayReady request.');
-    const dom = shaka.util.XmlUtils.parseXmlString(xml, 'PlayReadyKeyMessage');
+    const dom = TXml.parseXmlString(xml, 'PlayReadyKeyMessage');
     goog.asserts.assert(dom, 'Failed to parse PlayReady XML!');
 
     // Set request headers.
-    const headers = dom.getElementsByTagName('HttpHeader');
+    const headers = TXml.getElementsByTagName(dom, 'HttpHeader');
     for (const header of headers) {
-      const name = header.getElementsByTagName('name')[0];
-      const value = header.getElementsByTagName('value')[0];
+      const name = TXml.getElementsByTagName(header, 'name')[0];
+      const value = TXml.getElementsByTagName(header, 'value')[0];
       goog.asserts.assert(name && value, 'Malformed PlayReady headers!');
-      request.headers[name.textContent] = value.textContent;
+      request.headers[
+          /** @type {string} */(shaka.util.TXml.getTextContents(name))] =
+        /** @type {string} */(shaka.util.TXml.getTextContents(value));
     }
 
     // Unpack the base64-encoded challenge.
-    const challenge = dom.getElementsByTagName('Challenge')[0];
-    goog.asserts.assert(challenge, 'Malformed PlayReady challenge!');
-    goog.asserts.assert(challenge.getAttribute('encoding') == 'base64encoded',
+    const challenge = TXml.getElementsByTagName(dom, 'Challenge')[0];
+    goog.asserts.assert(challenge,
+        'Malformed PlayReady challenge!');
+    goog.asserts.assert(challenge.attributes['encoding'] == 'base64encoded',
         'Unexpected PlayReady challenge encoding!');
-    request.body = shaka.util.Uint8ArrayUtils.fromBase64(challenge.textContent);
+    request.body = shaka.util.Uint8ArrayUtils.fromBase64(
+        /** @type{string} */(shaka.util.TXml.getTextContents(challenge)));
   }
 
   /**
@@ -1829,7 +1803,6 @@ shaka.media.DrmEngine = class {
       'com.microsoft.playready.recommendation',
       'com.apple.fps.1_0',
       'com.apple.fps',
-      'com.adobe.primetime',
     ];
 
     const basicVideoCapabilities = [
@@ -2195,6 +2168,9 @@ shaka.media.DrmEngine = class {
    * @private
    */
   createDrmInfoByInfos_(keySystem, drmInfos) {
+    /** @type {!Array.<string>} */
+    const encryptionSchemes = [];
+
     /** @type {!Array.<string>} */
     const licenseServers = [];
 
@@ -2211,9 +2187,14 @@ shaka.media.DrmEngine = class {
     const keyIds = new Set();
 
     shaka.media.DrmEngine.processDrmInfos_(
-        drmInfos, licenseServers, serverCerts,
+        drmInfos, encryptionSchemes, licenseServers, serverCerts,
         serverCertificateUris, initDatas, keyIds);
 
+    if (encryptionSchemes.length > 1) {
+      shaka.log.warning('Multiple unique encryption schemes found! ' +
+                        'Only the first will be used.');
+    }
+
     if (serverCerts.length > 1) {
       shaka.log.warning('Multiple unique server certificates found! ' +
                         'Only the first will be used.');
@@ -2235,6 +2216,7 @@ shaka.media.DrmEngine = class {
     /** @type {shaka.extern.DrmInfo} */
     const res = {
       keySystem,
+      encryptionScheme: encryptionSchemes[0],
       licenseServerUri: licenseServers[0],
       distinctiveIdentifierRequired: drmInfos[0].distinctiveIdentifierRequired,
       persistentStateRequired: drmInfos[0].persistentStateRequired,
@@ -2271,6 +2253,9 @@ shaka.media.DrmEngine = class {
    * @private
    */
   static createDrmInfoByConfigs_(keySystem, config) {
+    /** @type {!Array.<string>} */
+    const encryptionSchemes = [];
+
     /** @type {!Array.<string>} */
     const licenseServers = [];
 
@@ -2288,9 +2273,14 @@ shaka.media.DrmEngine = class {
 
     // TODO: refactor, don't stick drmInfos onto MediaKeySystemConfiguration
     shaka.media.DrmEngine.processDrmInfos_(
-        config['drmInfos'], licenseServers, serverCerts,
+        config['drmInfos'], encryptionSchemes, licenseServers, serverCerts,
         serverCertificateUris, initDatas, keyIds);
 
+    if (encryptionSchemes.length > 1) {
+      shaka.log.warning('Multiple unique encryption schemes found! ' +
+                        'Only the first will be used.');
+    }
+
     if (serverCerts.length > 1) {
       shaka.log.warning('Multiple unique server certificates found! ' +
                         'Only the first will be used.');
@@ -2315,6 +2305,7 @@ shaka.media.DrmEngine = class {
     const distinctiveIdentifier = config.distinctiveIdentifier;
     return {
       keySystem,
+      encryptionScheme: encryptionSchemes[0],
       licenseServerUri: licenseServers[0],
       distinctiveIdentifierRequired: (distinctiveIdentifier == 'required'),
       persistentStateRequired: (config.persistentState == 'required'),
@@ -2334,6 +2325,7 @@ shaka.media.DrmEngine = class {
    *
    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
    * @param {!Array.<string>} licenseServers
+   * @param {!Array.<string>} encryptionSchemes
    * @param {!Array.<!Uint8Array>} serverCerts
    * @param {!Array.<string>} serverCertificateUris
    * @param {!Array.<!shaka.extern.InitDataOverride>} initDatas
@@ -2341,7 +2333,7 @@ shaka.media.DrmEngine = class {
    * @private
    */
   static processDrmInfos_(
-      drmInfos, licenseServers, serverCerts,
+      drmInfos, encryptionSchemes, licenseServers, serverCerts,
       serverCertificateUris, initDatas, keyIds) {
     /** @type {function(shaka.extern.InitDataOverride,
      *                  shaka.extern.InitDataOverride):boolean} */
@@ -2355,9 +2347,22 @@ shaka.media.DrmEngine = class {
          shaka.util.BufferUtils.equal(a.initData, b.initData);
     };
 
+    const clearkeyDataStart = 'data:application/json;base64,';
+    const clearKeyLicenseServers = [];
+
     for (const drmInfo of drmInfos) {
+      // Build an array of unique encryption schemes.
+      if (!encryptionSchemes.includes(drmInfo.encryptionScheme)) {
+        encryptionSchemes.push(drmInfo.encryptionScheme);
+      }
+
       // Build an array of unique license servers.
-      if (!licenseServers.includes(drmInfo.licenseServerUri)) {
+      if (drmInfo.keySystem == 'org.w3.clearkey' &&
+          drmInfo.licenseServerUri.startsWith(clearkeyDataStart)) {
+        if (!clearKeyLicenseServers.includes(drmInfo.licenseServerUri)) {
+          clearKeyLicenseServers.push(drmInfo.licenseServerUri);
+        }
+      } else if (!licenseServers.includes(drmInfo.licenseServerUri)) {
         licenseServers.push(drmInfo.licenseServerUri);
       }
 
@@ -2394,6 +2399,21 @@ shaka.media.DrmEngine = class {
         }
       }
     }
+
+    if (clearKeyLicenseServers.length == 1) {
+      licenseServers.push(clearKeyLicenseServers[0]);
+    } else if (clearKeyLicenseServers.length > 0) {
+      const keys = [];
+      for (const clearKeyLicenseServer of clearKeyLicenseServers) {
+        const license = window.atob(
+            clearKeyLicenseServer.split(clearkeyDataStart).pop());
+        const jwkSet = /** @type {{keys: !Array}} */(JSON.parse(license));
+        keys.push(...jwkSet.keys);
+      }
+      const newJwkSet = {keys: keys};
+      const newLicense = JSON.stringify(newJwkSet);
+      licenseServers.push(clearkeyDataStart + window.btoa(newLicense));
+    }
   }
 
   /**

package/lib/media/manifest_filterer.js

@@ -0,0 +1,220 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.ManifestFilterer');
+
+goog.require('goog.asserts');
+goog.require('shaka.util.StreamUtils');
+goog.require('shaka.media.DrmEngine');
+goog.require('shaka.util.Error');
+
+/**
+ * A class that handles the filtering of manifests.
+ * Allows for manifest filtering to be done both by the player and by a
+ * preload manager.
+ */
+shaka.media.ManifestFilterer = class {
+  /**
+   * @param {?shaka.extern.PlayerConfiguration} config
+   * @param {{width: number, height: number}} maxHwRes
+   * @param {?shaka.media.DrmEngine} drmEngine
+   */
+  constructor(config, maxHwRes, drmEngine) {
+    goog.asserts.assert(config, 'Must have config');
+
+    /** @private {!shaka.extern.PlayerConfiguration} */
+    this.config_ = config;
+
+    /** @private {{width: number, height: number}} */
+    this.maxHwRes_ = maxHwRes;
+
+    /** @private {?shaka.media.DrmEngine} drmEngine */
+    this.drmEngine_ = drmEngine;
+  }
+
+  /** @param {!shaka.media.DrmEngine} drmEngine */
+  setDrmEngine(drmEngine) {
+    this.drmEngine_ = drmEngine;
+  }
+
+  /**
+   * Filters a manifest, removing unplayable streams/variants.
+   *
+   * @param {?shaka.extern.Manifest} manifest
+   * @return {!Promise.<boolean>} tracksChanged
+   */
+  async filterManifest(manifest) {
+    await this.filterManifestWithStreamUtils_(manifest);
+    return this.filterManifestWithRestrictions(manifest);
+  }
+
+  /**
+   * Filters a manifest, removing unplayable streams/variants.
+   *
+   * @param {?shaka.extern.Manifest} manifest
+   * @private
+   */
+  async filterManifestWithStreamUtils_(manifest) {
+    goog.asserts.assert(manifest, 'Manifest should exist!');
+    await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest,
+        this.config_.drm.preferredKeySystems);
+    this.checkPlayableVariants_(manifest);
+  }
+
+
+  /**
+   * @param {?shaka.extern.Manifest} manifest
+   * @return {boolean} tracksChanged
+   */
+  applyRestrictions(manifest) {
+    return shaka.util.StreamUtils.applyRestrictions(
+        manifest.variants, this.config_.restrictions, this.maxHwRes_);
+  }
+
+
+  /**
+   * Apply the restrictions configuration to the manifest, and check if there's
+   * a variant that meets the restrictions.
+   *
+   * @param {?shaka.extern.Manifest} manifest
+   * @return {boolean} tracksChanged
+   */
+  filterManifestWithRestrictions(manifest) {
+    const tracksChanged = this.applyRestrictions(manifest);
+
+    if (manifest) {
+      // We may need to create new sessions for any new init data.
+      const currentDrmInfo =
+          this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
+      // DrmEngine.newInitData() requires mediaKeys to be available.
+      if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
+        for (const variant of manifest.variants) {
+          this.processDrmInfos(currentDrmInfo.keySystem, variant.video);
+          this.processDrmInfos(currentDrmInfo.keySystem, variant.audio);
+        }
+      }
+      this.checkRestrictedVariants(manifest);
+    }
+
+    return tracksChanged;
+  }
+
+  /**
+   * Confirm some variants are playable. Otherwise, throw an exception.
+   * @param {!shaka.extern.Manifest} manifest
+   * @private
+   */
+  checkPlayableVariants_(manifest) {
+    const valid = manifest.variants.some(shaka.util.StreamUtils.isPlayable);
+
+    // If none of the variants are playable, throw
+    // CONTENT_UNSUPPORTED_BY_BROWSER.
+    if (!valid) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.CONTENT_UNSUPPORTED_BY_BROWSER);
+    }
+  }
+
+  /**
+   * @param {string} keySystem
+   * @param {?shaka.extern.Stream} stream
+   */
+  processDrmInfos(keySystem, stream) {
+    if (!stream) {
+      return;
+    }
+
+    for (const drmInfo of stream.drmInfos) {
+      // Ignore any data for different key systems.
+      if (drmInfo.keySystem == keySystem) {
+        for (const initData of (drmInfo.initData || [])) {
+          this.drmEngine_.newInitData(
+              initData.initDataType, initData.initData);
+        }
+      }
+    }
+  }
+
+  /**
+   * Checks if the variants are all restricted, and throw an appropriate
+   * exception if so.
+   *
+   * @param {shaka.extern.Manifest} manifest
+   */
+  checkRestrictedVariants(manifest) {
+    const restrictedStatuses = shaka.media.ManifestFilterer.restrictedStatuses;
+    const keyStatusMap =
+        this.drmEngine_ ? this.drmEngine_.getKeyStatuses() : {};
+    const keyIds = Object.keys(keyStatusMap);
+    const isGlobalStatus = keyIds.length && keyIds[0] == '00';
+
+    let hasPlayable = false;
+    let hasAppRestrictions = false;
+
+    /** @type {!Set.<string>} */
+    const missingKeys = new Set();
+
+    /** @type {!Set.<string>} */
+    const badKeyStatuses = new Set();
+
+    for (const variant of manifest.variants) {
+      // TODO: Combine with onKeyStatus_.
+      const streams = [];
+      if (variant.audio) {
+        streams.push(variant.audio);
+      }
+      if (variant.video) {
+        streams.push(variant.video);
+      }
+
+      for (const stream of streams) {
+        if (stream.keyIds.size) {
+          for (const keyId of stream.keyIds) {
+            const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
+            if (!keyStatus) {
+              missingKeys.add(keyId);
+            } else if (restrictedStatuses.includes(keyStatus)) {
+              badKeyStatuses.add(keyStatus);
+            }
+          }
+        }  // if (stream.keyIds.size)
+      }
+
+      if (!variant.allowedByApplication) {
+        hasAppRestrictions = true;
+      } else if (variant.allowedByKeySystem) {
+        hasPlayable = true;
+      }
+    }
+
+    if (!hasPlayable) {
+      /** @type {shaka.extern.RestrictionInfo} */
+      const data = {
+        hasAppRestrictions,
+        missingKeys: Array.from(missingKeys),
+        restrictedKeyStatuses: Array.from(badKeyStatuses),
+      };
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET,
+          data);
+    }
+  }
+};
+
+/**
+ * These are the EME key statuses that represent restricted playback.
+ * 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
+ * of the usable keys.  'expired' status is being handled separately in
+ * DrmEngine.
+ *
+ * @const {!Array.<string>}
+ */
+shaka.media.ManifestFilterer.restrictedStatuses =
+    ['output-restricted', 'internal-error'];

package/lib/media/media_source_engine.js

@@ -557,7 +557,7 @@ shaka.media.MediaSourceEngine = class {
               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
         }
       }
-      const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      const type = this.addExtraFeaturesToMimeType_(mimeType);
 
       this.destroyer_.ensureNotDestroyed();
 
@@ -600,6 +600,9 @@ shaka.media.MediaSourceEngine = class {
    */
   configure(config) {
     this.config_ = config;
+    if (this.textEngine_) {
+      this.textEngine_.setModifyCueCallback(config.modifyCueCallback);
+    }
   }
 
   /**
@@ -621,6 +624,9 @@ shaka.media.MediaSourceEngine = class {
   reinitText(mimeType, sequenceMode, external) {
     if (!this.textEngine_) {
       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
+      if (this.textEngine_) {
+        this.textEngine_.setModifyCueCallback(this.config_.modifyCueCallback);
+      }
     }
     this.textEngine_.initParser(mimeType, sequenceMode,
         external || this.segmentRelativeVttTiming_, this.manifestType_);
@@ -1735,7 +1741,7 @@ shaka.media.MediaSourceEngine = class {
       if (transmuxer) {
         this.transmuxers_[contentType] = transmuxer;
       }
-      const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      const type = this.addExtraFeaturesToMimeType_(mimeType);
       this.sourceBuffers_[contentType].changeType(type);
       this.sourceBufferTypes_[contentType] = mimeType;
     } else {
@@ -1839,12 +1845,17 @@ shaka.media.MediaSourceEngine = class {
 
       const totalOfBuffers = streamsByType.size;
       let numberOfSourceBufferAdded = 0;
-      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer', (event) => {
+      const onSourceBufferAdded = () => {
         numberOfSourceBufferAdded++;
         if (numberOfSourceBufferAdded === totalOfBuffers) {
           sourceBufferAdded.resolve();
+          this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
+              onSourceBufferAdded);
         }
-      });
+      };
+
+      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
+          onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
         const stream = streamsByType.get(contentType);
@@ -1868,7 +1879,12 @@ shaka.media.MediaSourceEngine = class {
       this.destroyer_.ensureNotDestroyed();
 
       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
-        this.destroyer_.ensureNotDestroyed();
+        // Don't use ensureNotDestroyed() from this event listener, because
+        // that results in an uncaught exception.  Instead, just check the
+        // flag.
+        if (this.destroyer_.destroyed()) {
+          return;
+        }
 
         this.video_.autoplay = previousAutoPlayState;
         if (!previousPausedState) {
@@ -2054,6 +2070,19 @@ shaka.media.MediaSourceEngine = class {
   updateLcevcDec(lcevcDec) {
     this.lcevcDec_ = lcevcDec;
   }
+
+  /**
+   * @param {string} mimeType
+   * @return {string}
+   * @private
+   */
+  addExtraFeaturesToMimeType_(mimeType) {
+    const extraFeatures = this.config_.addExtraFeaturesToSourceBuffer(mimeType);
+    const extendedType = mimeType + extraFeatures;
+    shaka.log.debug('Using full mime type', extendedType);
+
+    return extendedType;
+  }
 };