shaka-player 4.12.4 → 4.12.6

package/externs/shaka/codecs.js

@@ -27,6 +27,27 @@
 shaka.extern.MPEG_PES;
 
 
+/**
+ * @typedef {{
+ *   data: !Uint8Array,
+ *   frame: boolean,
+ *   isKeyframe: boolean,
+ *   pts: ?number,
+ *   dts: ?number,
+ *   nalus: !Array.<!shaka.extern.VideoNalu>
+ * }}
+ *
+ * @summary VideoSample.
+ * @property {!Uint8Array} data
+ * @property {boolean} frame
+ * @property {boolean} isKeyframe
+ * @property {?number} pts
+ * @property {?number} dts
+ * @property {!Array.<!shaka.extern.VideoNalu>} nalus
+ */
+shaka.extern.VideoSample;
+
+
 /**
  * @typedef {{
  *   data: !Uint8Array,

package/externs/shaka/offline.js

@@ -141,6 +141,7 @@ shaka.extern.ManifestDB;
  *   spatialAudio: boolean,
  *   closedCaptions: Map.<string, string>,
  *   tilesLayout: (string|undefined),
+ *   mssPrivateData: (shaka.extern.MssPrivateData|undefined),
  *   external: boolean,
  *   fastSwitching: boolean,
  *   isAudioMuxedInVideo: boolean
@@ -214,6 +215,9 @@ shaka.extern.ManifestDB;
  *   The value is a grid-item-dimension consisting of two positive decimal
  *   integers in the format: column-x-row ('4x3'). It describes the arrangement
  *   of Images in a Grid. The minimum valid LAYOUT is '1x1'.
+ * @property {(shaka.extern.MssPrivateData|undefined)} mssPrivateData
+ *   <i>Microsoft Smooth Streaming only.</i> <br>
+ *   Private MSS data that is necessary to be able to do transmuxing.
  * @property {boolean} external
  *   Indicate if the stream was added externally.
  *   Eg: external text tracks.

package/lib/cast/cast_utils.js

@@ -329,6 +329,7 @@ shaka.cast.CastUtils.PlayerGetterMethods = {
   'getLoadMode': 10,
   'getManifestType': 10,
   'isFullyLoaded': 1,
+  'isEnded': 1,
 };
 
 

package/lib/dash/dash_parser.js

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

package/lib/hls/hls_parser.js

@@ -1136,8 +1136,8 @@ shaka.hls.HlsParser = class {
 
     if (shaka.util.TsParser.probe(
         shaka.util.BufferUtils.toUint8(data))) {
-      const basicInfo =
-          shaka.media.SegmentUtils.getBasicInfoFromTs(data);
+      const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromTs(
+          data, this.config_.disableAudio, this.config_.disableVideo);
       if (basicInfo) {
         return basicInfo;
       }
@@ -2763,12 +2763,23 @@ shaka.hls.HlsParser = class {
       }
     }
     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
-    const liveWithNoProgramaDateTime =
+
+    const activeStreamInfos = Array.from(this.uriToStreamInfosMap_.values())
+        .filter((s) => s.stream.segmentIndex);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const hasAudio =
+        activeStreamInfos.some((s) => s.stream.type == ContentType.AUDIO);
+    const hasVideo =
+        activeStreamInfos.some((s) => s.stream.type == ContentType.VIDEO);
+
+    const liveWithNoProgramDateTime =
         this.isLive_() && !this.usesProgramDateTime_;
+    const vodWithOnlyAudioOrVideo = !this.isLive_() &&
+        this.usesProgramDateTime_ && !(hasAudio && hasVideo);
     if (this.config_.hls.ignoreManifestProgramDateTime ||
-        liveWithNoProgramaDateTime) {
+        liveWithNoProgramDateTime || vodWithOnlyAudioOrVideo) {
       this.syncStreamsWithSequenceNumber_(
-          streamInfos, liveWithNoProgramaDateTime);
+          streamInfos, liveWithNoProgramDateTime);
     } else {
       this.syncStreamsWithProgramDateTime_(streamInfos);
       if (this.config_.hls.ignoreManifestProgramDateTimeForTypes.length > 0) {
@@ -2906,6 +2917,16 @@ shaka.hls.HlsParser = class {
 
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, segments);
+
+      // Some manifests don't say what text codec they use, this is a problem
+      // if the cmft extension is used because we identify the mimeType as
+      // application/mp4. In this case if we don't detect initialization
+      // segments, we assume that the mimeType is text/vtt.
+      if (type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
+          !codecs && mimeType == 'application/mp4' &&
+          segments[0] && !segments[0].initSegmentReference) {
+        mimeType = 'text/vtt';
+      }
     }
 
     const {drmInfos, keyIds, encrypted, aesEncrypted} =

package/lib/media/drm_engine.js

@@ -928,14 +928,16 @@ shaka.media.DrmEngine = class {
           'Got MediaKeySystemAccess with configuration',
           realConfig);
 
+      const keySystem =
+          this.config_.keySystemsMapping[mediaKeySystemAccess.keySystem] ||
+          mediaKeySystemAccess.keySystem;
+
       if (variants.length) {
         this.currentDrmInfo_ = this.createDrmInfoByInfos_(
-            mediaKeySystemAccess.keySystem,
-            drmInfosByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, drmInfosByKeySystem.get(keySystem));
       } else {
         this.currentDrmInfo_ = shaka.media.DrmEngine.createDrmInfoByConfigs_(
-            mediaKeySystemAccess.keySystem,
-            configsByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, configsByKeySystem.get(keySystem));
       }
       if (!this.currentDrmInfo_.licenseServerUri) {
         throw new shaka.util.Error(
@@ -1050,8 +1052,12 @@ shaka.media.DrmEngine = class {
           if (!decodingInfo.supported || !decodingInfo.keySystemAccess) {
             continue;
           }
-          const drmInfos =
-              drmInfosByKeySystem.get(decodingInfo.keySystemAccess.keySystem);
+          const originalKeySystem = decodingInfo.keySystemAccess.keySystem;
+          let drmInfos = drmInfosByKeySystem.get(originalKeySystem);
+          if (!drmInfos && this.config_.keySystemsMapping[originalKeySystem]) {
+            drmInfos = drmInfosByKeySystem.get(
+                this.config_.keySystemsMapping[originalKeySystem]);
+          }
           for (const info of drmInfos) {
             if (!!info.licenseServerUri == shouldHaveLicenseServer) {
               return decodingInfo.keySystemAccess;
@@ -1450,6 +1456,11 @@ shaka.media.DrmEngine = class {
     }
     // NOTE: allowCrossSiteCredentials can be set in a request filter.
 
+    if (shaka.util.DrmUtils.isClearKeySystem(
+        this.currentDrmInfo_.keySystem)) {
+      this.fixClearKeyRequest_(request, this.currentDrmInfo_);
+    }
+
     if (shaka.util.DrmUtils.isPlayReadyKeySystem(
         this.currentDrmInfo_.keySystem)) {
       this.unpackPlayReadyRequest_(request);
@@ -1603,6 +1614,31 @@ shaka.media.DrmEngine = class {
         /** @type{string} */(shaka.util.TXml.getTextContents(challenge)));
   }
 
+  /**
+   * Some old ClearKey CDMs don't include the type in the body request.
+   *
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.DrmInfo} drmInfo
+   * @private
+   */
+  fixClearKeyRequest_(request, drmInfo) {
+    try {
+      const body = shaka.util.StringUtils.fromBytesAutoDetect(request.body);
+      if (body) {
+        const licenseBody =
+          /** @type {shaka.media.DrmEngine.ClearKeyLicenceRequestFormat} */ (
+            JSON.parse(body));
+        if (!licenseBody.type) {
+          licenseBody.type = drmInfo.sessionType;
+          request.body =
+              shaka.util.StringUtils.toUTF8(JSON.stringify(licenseBody));
+        }
+      }
+    } catch (e) {
+      shaka.log.info('Error unpacking ClearKey license', e);
+    }
+  }
+
   /**
    * @param {!Event} event
    * @private
@@ -2001,18 +2037,10 @@ shaka.media.DrmEngine = class {
    * @private
    */
   async closeSession_(session) {
-    const DrmEngine = shaka.media.DrmEngine;
-
-    const timeout = new Promise((resolve, reject) => {
-      const timer = new shaka.util.Timer(reject);
-      timer.tickAfter(DrmEngine.CLOSE_TIMEOUT_);
-    });
-
     try {
-      await Promise.race([
-        Promise.all([session.close(), session.closed]),
-        timeout,
-      ]);
+      await shaka.util.Functional.promiseWithTimeout(
+          shaka.media.DrmEngine.CLOSE_TIMEOUT_,
+          Promise.all([session.close(), session.closed]));
     } catch (e) {
       shaka.log.warning('Timeout waiting for session close');
     }
@@ -2452,26 +2480,24 @@ shaka.media.DrmEngine = class {
     // The order of preference for drmInfo:
     // 1. Clear Key config, used for debugging, should override everything else.
     //    (The application can still specify a clearkey license server.)
-    // 2. Application-configured servers, if any are present, should override
-    //    anything from the manifest.  Nuance: if key system A is in the
-    //    manifest and key system B is in the player config, only B will be
-    //    used, not A.
+    // 2. Application-configured servers, if present, override
+    //    anything from the manifest.
     // 3. Manifest-provided license servers are only used if nothing else is
     //    specified.
     // This is important because it allows the application a clear way to
-    // indicate which DRM systems should be used on platforms with multiple DRM
-    // systems.
-    // The only way to get license servers from the manifest is not to specify
-    // any in your player config.
+    // indicate which DRM systems should be ignored on platforms with multiple
+    // DRM systems.
+    // Alternatively, use config.preferredKeySystems to specify the preferred
+    // key system.
 
     if (originalKeySystem == 'org.w3.clearkey' && drmInfo.licenseServerUri) {
       // Preference 1: Clear Key with pre-configured keys will have a data URI
       // assigned as its license server.  Don't change anything.
       return;
-    } else if (servers.size) {
-      // Preference 2: If anything is configured at the application level,
-      // override whatever was in the manifest.
-      const server = servers.get(originalKeySystem) || '';
+    } else if (servers.size && servers.get(originalKeySystem)) {
+      // Preference 2: If a license server for this keySystem is configured at
+      // the application level, override whatever was in the manifest.
+      const server = servers.get(originalKeySystem);
 
       drmInfo.licenseServerUri = server;
     } else {
@@ -2632,6 +2658,21 @@ shaka.media.DrmEngine.SessionMetaData;
  */
 shaka.media.DrmEngine.PlayerInterface;
 
+/**
+ * @typedef {{
+ *   kids: !Array.<string>,
+ *   type: string
+ * }}
+ *
+ * @property {!Array.<string>} kids
+ *   An array of key IDs. Each element of the array is the base64url encoding of
+ *   the octet sequence containing the key ID value.
+ * @property {string} type
+ *   The requested MediaKeySessionType.
+ * @see https://www.w3.org/TR/encrypted-media/#clear-key-request-format
+ */
+shaka.media.DrmEngine.ClearKeyLicenceRequestFormat;
+
 /**
  * The amount of time, in seconds, we wait to consider a session closed.
  * This allows us to work around Chrome bug https://crbug.com/1108158.

package/lib/media/manifest_filterer.js

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