shaka-player 4.3.11 → 4.4.1

package/lib/hls/manifest_text_parser.js

@@ -158,15 +158,7 @@ shaka.hls.ManifestTextParser = class {
             partialSegmentTags.push(tag);
           } else if (tag.name == 'EXT-X-PRELOAD-HINT') {
             if (tag.getAttributeValue('TYPE') == 'PART') {
-              // Note: BYTERANGE-START without BYTERANGE-LENGTH is being
-              // ignored.
-              if (tag.getAttributeValue('BYTERANGE-START') != null) {
-                if (tag.getAttributeValue('BYTERANGE-LENGTH') != null) {
-                  partialSegmentTags.push(tag);
-                }
-              } else {
-                partialSegmentTags.push(tag);
-              }
+              partialSegmentTags.push(tag);
             } else if (tag.getAttributeValue('TYPE') == 'MAP') {
               // Rename the Preload Hint tag to be a Map tag.
               tag.setName('EXT-X-MAP');
@@ -180,15 +172,13 @@ shaka.hls.ManifestTextParser = class {
         // Skip comments.
       } else {
         const verbatimSegmentUri = line.trim();
-        const absoluteSegmentUri = shaka.hls.Utils.constructAbsoluteUri(
-            absoluteMediaPlaylistUri, verbatimSegmentUri);
         // Attach the last parsed EXT-X-MAP tag to the segment.
         if (currentMapTag) {
           segmentTags.push(currentMapTag);
         }
         // The URI appears after all of the tags describing the segment.
-        const segment = new shaka.hls.Segment(absoluteSegmentUri, segmentTags,
-            partialSegmentTags);
+        const segment = new shaka.hls.Segment(absoluteMediaPlaylistUri,
+            verbatimSegmentUri, segmentTags, partialSegmentTags);
         segments.push(segment);
         segmentTags = [];
         partialSegmentTags = [];
@@ -203,7 +193,7 @@ shaka.hls.ManifestTextParser = class {
       if (currentMapTag) {
         segmentTags.push(currentMapTag);
       }
-      const segment = new shaka.hls.Segment('', segmentTags,
+      const segment = new shaka.hls.Segment('', '', segmentTags,
           partialSegmentTags);
       segments.push(segment);
     }

package/lib/media/adaptation_set_criteria.js

@@ -49,13 +49,14 @@ shaka.media.ExampleBasedCriteria = class {
     // role and label for this.
     const role = '';
     const label = '';
+    const hdrLevel = '';
     const channelCount = example.audio && example.audio.channelsCount ?
                          example.audio.channelsCount :
                          0;
 
     /** @private {!shaka.media.AdaptationSetCriteria} */
     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
-        example.language, role, channelCount, label);
+        example.language, role, channelCount, hdrLevel, label);
   }
 
   /** @override */
@@ -87,9 +88,10 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {string} language
    * @param {string} role
    * @param {number} channelCount
+   * @param {string} hdrLevel
    * @param {string=} label
    */
-  constructor(language, role, channelCount, label = '') {
+  constructor(language, role, channelCount, hdrLevel, label = '') {
     /** @private {string} */
     this.language_ = language;
     /** @private {string} */
@@ -97,6 +99,8 @@ shaka.media.PreferenceBasedCriteria = class {
     /** @private {number} */
     this.channelCount_ = channelCount;
     /** @private {string} */
+    this.hdrLevel_ = hdrLevel;
+    /** @private {string} */
     this.label_ = label;
   }
 
@@ -127,6 +131,17 @@ shaka.media.PreferenceBasedCriteria = class {
       shaka.log.warning('No exact match for variant role could be found.');
     }
 
+    if (this.hdrLevel_) {
+      const byHdrLevel = Class.filterVariantsByHDRLevel_(
+          current, this.hdrLevel_);
+      if (byHdrLevel.length) {
+        current = byHdrLevel;
+      } else {
+        shaka.log.warning(
+            'No exact match for the hdr level could be found.');
+      }
+    }
+
     if (this.channelCount_) {
       const byChannel = StreamUtils.filterVariantsByAudioChannelCount(
           current, this.channelCount_);
@@ -218,7 +233,7 @@ shaka.media.PreferenceBasedCriteria = class {
    */
   static filterVariantsByLabel_(variants, preferredLabel) {
     return variants.filter((variant) => {
-      if (!variant.audio) {
+      if (!variant.audio || !variant.audio.label) {
         return false;
       }
 
@@ -227,4 +242,29 @@ shaka.media.PreferenceBasedCriteria = class {
       return label1 == label2;
     });
   }
+
+
+  /**
+   * Filters variants according to the given hdr level config.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {string} hdrLevel
+   * @private
+   */
+  static filterVariantsByHDRLevel_(variants, hdrLevel) {
+    if (hdrLevel == 'AUTO') {
+      // Auto detect the ideal HDR level.
+      if (window.matchMedia('(color-gamut: p3)').matches) {
+        hdrLevel = 'PQ';
+      } else {
+        hdrLevel = 'SDR';
+      }
+    }
+    return variants.filter((variant) => {
+      if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
+        return false;
+      }
+      return true;
+    });
+  }
 };

package/lib/media/closed_caption_parser.js

@@ -7,12 +7,9 @@
 goog.provide('shaka.media.ClosedCaptionParser');
 goog.provide('shaka.media.IClosedCaptionParser');
 
-goog.require('shaka.cea.CeaDecoder');
+goog.require('shaka.cea.DummyCaptionDecoder');
 goog.require('shaka.cea.DummyCeaParser');
-goog.require('shaka.cea.Mp4CeaParser');
 goog.require('shaka.util.BufferUtils');
-goog.requireType('shaka.cea.ICaptionDecoder');
-goog.requireType('shaka.cea.ICeaParser');
 
 
 /**
@@ -21,6 +18,7 @@ goog.requireType('shaka.cea.ICeaParser');
  * TODO: Remove this interface and move method definitions
  * directly to ClosedCaptonParser.
  * @interface
+ * @export
  */
 shaka.media.IClosedCaptionParser = class {
   /**
@@ -35,7 +33,7 @@ shaka.media.IClosedCaptionParser = class {
    * captions.
    *
    * @param {BufferSource} mediaFragment
-   * @return {!Array<!shaka.cea.ICaptionDecoder.ClosedCaption>}
+   * @return {!Array<!shaka.extern.ICaptionDecoder.ClosedCaption>}
    * An array of parsed closed captions.
    */
   parseFrom(mediaFragment) {}
@@ -52,23 +50,32 @@ shaka.media.IClosedCaptionParser = class {
  *
  * @implements {shaka.media.IClosedCaptionParser}
  * @final
+ * @export
  */
 shaka.media.ClosedCaptionParser = class {
-  /** */
+  /**
+   * @param {string} mimeType
+   */
   constructor(mimeType) {
-    /** @private {!shaka.cea.ICeaParser} */
+    /** @private {!shaka.extern.ICeaParser} */
     this.ceaParser_ = new shaka.cea.DummyCeaParser();
 
-    if (mimeType.includes('video/mp4')) {
-      // MP4 Parser to extract closed caption packets from H.264 video.
-      this.ceaParser_ = new shaka.cea.Mp4CeaParser();
+    const parserFactory =
+        shaka.media.ClosedCaptionParser.findParser(mimeType.toLowerCase());
+    if (parserFactory) {
+      this.ceaParser_ = parserFactory();
     }
 
     /**
      * Decoder for decoding CEA-X08 data from closed caption packets.
-     * @private {!shaka.cea.ICaptionDecoder}
+     * @private {!shaka.extern.ICaptionDecoder}
      */
-    this.ceaDecoder_ = new shaka.cea.CeaDecoder();
+    this.ceaDecoder_ = new shaka.cea.DummyCaptionDecoder();
+
+    const decoderFactory = shaka.media.ClosedCaptionParser.findDecoder();
+    if (decoderFactory) {
+      this.ceaDecoder_ = decoderFactory();
+    }
   }
 
   /**
@@ -104,4 +111,59 @@ shaka.media.ClosedCaptionParser = class {
   reset() {
     this.ceaDecoder_.clear();
   }
+
+  /**
+   * @param {string} mimeType
+   * @param {!shaka.extern.CeaParserPlugin} plugin
+   * @export
+   */
+  static registerParser(mimeType, plugin) {
+    shaka.media.ClosedCaptionParser.parserMap_[mimeType] = plugin;
+  }
+
+  /**
+   * @param {string} mimeType
+   * @export
+   */
+  static unregisterParser(mimeType) {
+    delete shaka.media.ClosedCaptionParser.parserMap_[mimeType];
+  }
+
+  /**
+   * @param {string} mimeType
+   * @return {?shaka.extern.CeaParserPlugin}
+   * @export
+   */
+  static findParser(mimeType) {
+    return shaka.media.ClosedCaptionParser.parserMap_[mimeType];
+  }
+
+  /**
+   * @param {!shaka.extern.CaptionDecoderPlugin} plugin
+   * @export
+   */
+  static registerDecoder(plugin) {
+    shaka.media.ClosedCaptionParser.decoderFactory_ = plugin;
+  }
+
+  /**
+   * @export
+   */
+  static unregisterDecoder() {
+    shaka.media.ClosedCaptionParser.decoderFactory_ = null;
+  }
+
+  /**
+   * @return {?shaka.extern.CaptionDecoderPlugin}
+   * @export
+   */
+  static findDecoder() {
+    return shaka.media.ClosedCaptionParser.decoderFactory_;
+  }
 };
+
+/** @private {!Object<string, shaka.extern.CeaParserPlugin>} */
+shaka.media.ClosedCaptionParser.parserMap_ = {};
+
+/** @private {?shaka.extern.CaptionDecoderPlugin} */
+shaka.media.ClosedCaptionParser.decoderFactory_ = null;

package/lib/media/drm_engine.js

@@ -8,8 +8,8 @@ goog.provide('shaka.media.DrmEngine');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.media.Transmuxer');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
@@ -71,8 +71,11 @@ shaka.media.DrmEngine = class {
      */
     this.activeSessions_ = new Map();
 
-    /** @private {!Array.<string>} */
-    this.offlineSessionIds_ = [];
+    /**
+     * @private {!Map<string,
+     *           {initData: ?Uint8Array, initDataType: ?string}>}
+     */
+    this.storedPersistentSessions_ = new Map();
 
     /** @private {!shaka.util.PublicPromise} */
     this.allSessionsLoaded_ = new shaka.util.PublicPromise();
@@ -82,7 +85,10 @@ shaka.media.DrmEngine = class {
 
     /** @private {function(!shaka.util.Error)} */
     this.onError_ = (err) => {
-      this.allSessionsLoaded_.reject(err);
+      if (err.severity == shaka.util.Error.Severity.CRITICAL) {
+        this.allSessionsLoaded_.reject(err);
+      }
+
       playerInterface.onError(err);
     };
 
@@ -187,7 +193,7 @@ shaka.media.DrmEngine = class {
     this.currentDrmInfo_ = null;
     this.supportedTypes_.clear();
     this.mediaKeys_ = null;
-    this.offlineSessionIds_ = [];
+    this.storedPersistentSessions_ = new Map();
     this.config_ = null;
     this.onError_ = () => {};
     this.playerInterface_ = null;
@@ -231,7 +237,7 @@ shaka.media.DrmEngine = class {
     //  2. We are about to remove the offline sessions for this manifest - in
     //     that case, we don't need to know about them right now either as
     //     we will be told which ones to remove later.
-    this.offlineSessionIds_ = [];
+    this.storedPersistentSessions_ = new Map();
 
     // What we really need to know is whether or not they are expecting to use
     // persistent licenses.
@@ -249,8 +255,20 @@ shaka.media.DrmEngine = class {
    * @return {!Promise}
    */
   initForPlayback(variants, offlineSessionIds) {
-    this.offlineSessionIds_ = offlineSessionIds;
-    this.usePersistentLicenses_ = offlineSessionIds.length > 0;
+    this.storedPersistentSessions_ = new Map();
+
+    for (const sessionId of offlineSessionIds) {
+      this.storedPersistentSessions_.set(
+          sessionId, {initData: null, initDataType: null});
+    }
+
+    for (const metadata of this.config_.persistentSessionsMetadata) {
+      this.storedPersistentSessions_.set(
+          metadata.sessionId,
+          {initData: metadata.initData, initDataType: metadata.initDataType});
+    }
+
+    this.usePersistentLicenses_ = this.storedPersistentSessions_.size > 0;
 
     return this.init_(variants);
   }
@@ -304,7 +322,7 @@ shaka.media.DrmEngine = class {
   /**
    * Negotiate for a key system and set up MediaKeys.
    * This will assume that both |usePersistentLicences_| and
-   * |offlineSessionIds_| have been properly set.
+   * |storedPersistentSessions_| have been properly set.
    *
    * @param {!Array.<shaka.extern.Variant>} variants
    *    The variants that we expect to operate with during the drm engine's
@@ -378,7 +396,8 @@ shaka.media.DrmEngine = class {
     // We should get the decodingInfo results for the variants after we filling
     // in the drm infos, and before queryMediaKeys_().
     await shaka.util.StreamUtils.getDecodingInfosForVariants(variants,
-        this.usePersistentLicenses_, this.srcEquals_);
+        this.usePersistentLicenses_, this.srcEquals_,
+        this.config_.preferredKeySystems);
 
     const hasDrmInfo = hadDrmInfo || Object.keys(this.config_.servers).length;
     // An unencrypted content is initialized.
@@ -502,18 +521,21 @@ shaka.media.DrmEngine = class {
      */
     if (this.manifestInitData_ ||
         this.currentDrmInfo_.keySystem !== 'com.apple.fps' ||
-        this.offlineSessionIds_.length) {
+        this.storedPersistentSessions_.size) {
       await this.attachMediaKeys_();
     }
 
-    this.createOrLoad();
+    this.createOrLoad().catch(() => {
+      // Silence errors
+      // createOrLoad will run async, errors are triggered through onError_
+    });
 
     // Explicit init data for any one stream or an offline session is
     // sufficient to suppress 'encrypted' events for all streams.
     // Also suppress 'encrypted' events when parsing in-band ppsh
     // from media segments because that serves the same purpose as the
     // 'encrypted' events.
-    if (!this.manifestInitData_ && !this.offlineSessionIds_.length &&
+    if (!this.manifestInitData_ && !this.storedPersistentSessions_.size &&
         !this.config_.parseInbandPsshEnabled) {
       this.eventManager_.listen(
           this.video_, 'encrypted', (e) => this.onEncryptedEvent_(e));
@@ -601,7 +623,8 @@ shaka.media.DrmEngine = class {
     goog.asserts.assert(this.mediaKeys_,
         'Must call init() before removeSession');
 
-    const session = await this.loadOfflineSession_(sessionId);
+    const session = await this.loadOfflineSession_(
+        sessionId, {initData: null, initDataType: null});
 
     // This will be null on error, such as session not found.
     if (!session) {
@@ -634,8 +657,30 @@ shaka.media.DrmEngine = class {
    *
    * @return {!Promise}
    */
-  createOrLoad() {
-    // Create temp sessions.
+  async createOrLoad() {
+    if (this.storedPersistentSessions_.size) {
+      this.storedPersistentSessions_.forEach((metadata, sessionId) => {
+        this.loadOfflineSession_(sessionId, metadata);
+      });
+
+      await this.allSessionsLoaded_;
+
+      const keyIds = (this.currentDrmInfo_ && this.currentDrmInfo_.keyIds) ||
+          new Set([]);
+
+      // All the needed keys are already loaded, we don't need another license
+      // Therefore we prevent starting a new session
+      if (keyIds.size > 0 && this.areAllKeysUsable_()) {
+        return this.allSessionsLoaded_;
+      }
+
+      // Reset the promise for the next sessions to come if key needs aren't
+      // satisfied with persistent sessions
+      this.allSessionsLoaded_ = new shaka.util.PublicPromise();
+      this.allSessionsLoaded_.catch(() => {});
+    }
+
+    // Create sessions.
     const initDatas =
         (this.currentDrmInfo_ ? this.currentDrmInfo_.initData : []) || [];
     for (const initDataOverride of initDatas) {
@@ -643,14 +688,9 @@ shaka.media.DrmEngine = class {
           initDataOverride.initDataType, initDataOverride.initData);
     }
 
-    // Load each session.
-    for (const sessionId of this.offlineSessionIds_) {
-      this.loadOfflineSession_(sessionId);
-    }
-
     // If we have no sessions, we need to resolve the promise right now or else
     // it will never get resolved.
-    if (!initDatas.length && !this.offlineSessionIds_.length) {
+    if (!initDatas.length) {
       this.allSessionsLoaded_.resolve();
     }
 
@@ -778,6 +818,28 @@ shaka.media.DrmEngine = class {
     return Array.from(ids);
   }
 
+  /**
+   * Returns the active sessions metadata
+   *
+   * @return {!Array.<shaka.extern.DrmSessionMetadata>}
+   */
+  getActiveSessionsMetadata() {
+    const sessions = this.activeSessions_.keys();
+
+    const metadata = shaka.util.Iterables.map(sessions, (session) => {
+      const metadata = this.activeSessions_.get(session);
+
+      return {
+        sessionId: session.sessionId,
+        sessionType: metadata.type,
+        initData: metadata.initData,
+        initDataType: metadata.initDataType,
+      };
+    });
+
+    return Array.from(metadata);
+  }
+
   /**
    * Returns the next expiration time, or Infinity.
    * @return {number}
@@ -853,10 +915,11 @@ shaka.media.DrmEngine = class {
   static computeMimeType_(stream, codecOverride) {
     const realMimeType = shaka.util.MimeUtils.getFullType(stream.mimeType,
         codecOverride || stream.codecs);
-    if (shaka.media.Transmuxer.isSupported(realMimeType)) {
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
+    if (TransmuxerEngine.isSupported(realMimeType, stream.type)) {
       // This will be handled by the Transmuxer, so use the MIME type that the
       // Transmuxer will produce.
-      return shaka.media.Transmuxer.convertCodecs(stream.type, realMimeType);
+      return TransmuxerEngine.convertCodecs(stream.type, realMimeType);
     }
     return realMimeType;
   }
@@ -934,6 +997,30 @@ shaka.media.DrmEngine = class {
           this.currentDrmInfo_.keySystem);
 
       this.mediaKeys_ = mediaKeys;
+      if (this.config_.minHdcpVersion != '' &&
+          'getStatusForPolicy' in this.mediaKeys_) {
+        try {
+          const status = await this.mediaKeys_.getStatusForPolicy({
+            minHdcpVersion: this.config_.minHdcpVersion,
+          });
+          if (status != 'usable') {
+            throw new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.DRM,
+                shaka.util.Error.Code.MIN_HDCP_VERSION_NOT_MATCH);
+          }
+          this.destroyer_.ensureNotDestroyed();
+        } catch (e) {
+          if (e instanceof shaka.util.Error) {
+            throw e;
+          }
+          throw new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.DRM,
+              shaka.util.Error.Code.ERROR_CHECKING_HDCP_VERSION,
+              e.message);
+        }
+      }
       this.initialized_ = true;
 
       await this.setServerCertificate();
@@ -1171,12 +1258,41 @@ shaka.media.DrmEngine = class {
     };
   }
 
+  /**
+   * Resolves the allSessionsLoaded_ promise when all the sessions are loaded
+   *
+   * @private
+   */
+  checkSessionsLoaded_() {
+    if (this.areAllSessionsLoaded_()) {
+      this.allSessionsLoaded_.resolve();
+    }
+  }
+
+  /**
+   * In case there are no key statuses, consider this session loaded
+   * after a reasonable timeout.  It should definitely not take 5
+   * seconds to process a license.
+   * @param {!shaka.media.DrmEngine.SessionMetaData} metadata
+   * @private
+   */
+  setLoadSessionTimeoutTimer_(metadata) {
+    const timer = new shaka.util.Timer(() => {
+      metadata.loaded = true;
+      this.checkSessionsLoaded_();
+    });
+
+    timer.tickAfter(
+        /* seconds= */ shaka.media.DrmEngine.SESSION_LOAD_TIMEOUT_);
+  }
+
   /**
    * @param {string} sessionId
+   * @param {{initData: ?Uint8Array, initDataType: ?string}} sessionMetadata
    * @return {!Promise.<MediaKeySession>}
    * @private
    */
-  async loadOfflineSession_(sessionId) {
+  async loadOfflineSession_(sessionId, sessionMetadata) {
     let session;
 
     const sessionType = 'persistent-license';
@@ -1201,8 +1317,8 @@ shaka.media.DrmEngine = class {
         (event) => this.onKeyStatusesChange_(event));
 
     const metadata = {
-      initData: null,
-      initDataType: null,
+      initData: sessionMetadata.initData,
+      initDataType: sessionMetadata.initDataType,
       loaded: false,
       oldExpiration: Infinity,
       updatePromise: null,
@@ -1218,32 +1334,42 @@ shaka.media.DrmEngine = class {
       if (!present) {
         this.activeSessions_.delete(session);
 
+        const severity = this.config_.persistentSessionOnlinePlayback ?
+            shaka.util.Error.Severity.RECOVERABLE :
+            shaka.util.Error.Severity.CRITICAL;
+
         this.onError_(new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
+            severity,
             shaka.util.Error.Category.DRM,
             shaka.util.Error.Code.OFFLINE_SESSION_REMOVED));
-        return Promise.resolve();
-      }
 
-      // TODO: We should get a key status change event.  Remove once Chrome CDM
-      // is fixed.
-      metadata.loaded = true;
-      if (this.areAllSessionsLoaded_()) {
-        this.allSessionsLoaded_.resolve();
+        metadata.loaded = true;
       }
 
+      this.setLoadSessionTimeoutTimer_(metadata);
+      this.checkSessionsLoaded_();
+
       return session;
     } catch (error) {
       this.destroyer_.ensureNotDestroyed(error);
 
       this.activeSessions_.delete(session);
 
+      const severity = this.config_.persistentSessionOnlinePlayback ?
+          shaka.util.Error.Severity.RECOVERABLE :
+          shaka.util.Error.Severity.CRITICAL;
+
       this.onError_(new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
+          severity,
           shaka.util.Error.Category.DRM,
           shaka.util.Error.Code.FAILED_TO_CREATE_SESSION,
           error.message));
+
+      metadata.loaded = true;
+
+      this.checkSessionsLoaded_();
     }
+
     return Promise.resolve();
   }
 
@@ -1469,18 +1595,8 @@ shaka.media.DrmEngine = class {
       if (metadata.updatePromise) {
         metadata.updatePromise.resolve();
       }
-      // In case there are no key statuses, consider this session loaded
-      // after a reasonable timeout.  It should definitely not take 5
-      // seconds to process a license.
-      const timer = new shaka.util.Timer(() => {
-        metadata.loaded = true;
-        if (this.areAllSessionsLoaded_()) {
-          this.allSessionsLoaded_.resolve();
-        }
-      });
 
-      timer.tickAfter(
-          /* seconds= */ shaka.media.DrmEngine.SESSION_LOAD_TIMEOUT_);
+      this.setLoadSessionTimeoutTimer_(metadata);
     }
   }
 
@@ -1828,8 +1944,9 @@ shaka.media.DrmEngine = class {
          * the playback session ends
          */
         if (!this.initializedForStorage_ &&
-            !this.offlineSessionIds_.includes(session.sessionId) &&
-            metadata.type === 'persistent-license') {
+            !this.storedPersistentSessions_.has(session.sessionId) &&
+            metadata.type === 'persistent-license' &&
+            !this.config_.persistentSessionOnlinePlayback) {
           shaka.log.v1('Removing session', session.sessionId);
 
           await session.remove();
@@ -1895,6 +2012,10 @@ shaka.media.DrmEngine = class {
       return true;
     }
 
+    if (drms1 === drms2) {
+      return true;
+    }
+
     return shaka.media.DrmEngine.getCommonDrmInfos(
         drms1, drms2).length > 0;
   }
@@ -2003,6 +2124,25 @@ shaka.media.DrmEngine = class {
     return shaka.util.Iterables.every(metadatas, (data) => data.loaded);
   }
 
+  /**
+   * @return {boolean}
+   * @private
+   */
+  areAllKeysUsable_() {
+    const keyIds = (this.currentDrmInfo_ && this.currentDrmInfo_.keyIds) ||
+        new Set([]);
+
+    for (const keyId of keyIds) {
+      const status = this.keyStatusByKeyId_.get(keyId);
+
+      if (status !== 'usable') {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   /**
    * Replace the drm info used in each variant in |variants| to reflect each
    * key service in |keySystems|.

package/lib/media/gap_jumping_controller.js

@@ -89,7 +89,7 @@ shaka.media.GapJumpingController = class {
      */
     this.gapJumpTimer_ = new shaka.util.Timer(() => {
       this.onPollGapJump_();
-    }).tickEvery(/* seconds= */ 0.25);
+    }).tickEvery(this.config_.gapJumpTimerTime);
   }