shaka-player 4.8.8 → 4.9.0

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 */
@@ -41,27 +41,23 @@ shaka.media.ManifestFilterer = class {
   }
 
   /**
-   * Filters a manifest, removing unplayable streams/variants.
+   * Filters a manifest, removing unplayable streams/variants and  choosing
+   * the codecs.
    *
    * @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);
+    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
+        manifest,
+        this.config_.preferredVideoCodecs,
+        this.config_.preferredAudioCodecs,
+        this.config_.preferredDecodingAttributes);
     this.checkPlayableVariants_(manifest);
+    return this.filterManifestWithRestrictions(manifest);
   }
 
 

package/lib/media/preload_manager.js

@@ -553,7 +553,9 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
 
     const tracksChangedInitial = this.manifestFilterer_.applyRestrictions(
         this.manifest_);
-    if (tracksChangedInitial) {
+    const tracksChangedBefore = await this.manifestFilterer_.filterManifest(
+        this.manifest_);
+    if (tracksChangedInitial || tracksChangedBefore) {
       const event = this.makeEvent_(
           shaka.util.FakeEvent.EventName.TracksChanged);
       await Promise.resolve();
@@ -568,7 +570,6 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
 
     // Now that we have drm information, filter the manifest (again) so that
     // we can ensure we only use variants with the selected key system.
-    // const tracksChanged =
     const tracksChangedAfter = await this.manifestFilterer_.filterManifest(
         this.manifest_);
     if (tracksChangedAfter) {
@@ -630,14 +631,6 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
               this.config_.preferredVideoLabel,
               this.config_.mediaSource.codecSwitchingStrategy,
               this.config_.manifest.dash.enableAudioGroups);
-
-      // If the content is multi-codec and the browser can play more than one of
-      // them, choose codecs now before we initialize streaming.
-      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
-          this.manifest_,
-          this.config_.preferredVideoCodecs,
-          this.config_.preferredAudioCodecs,
-          this.config_.preferredDecodingAttributes);
     }
 
     // Make the ABR manager.

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
@@ -146,6 +157,19 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     delete shaka.net.NetworkingEngine.schemes_[scheme];
   }
 
+  /**
+   * Copies all of the filters from this networking engine into another.
+   * @param {!shaka.net.NetworkingEngine} other
+   */
+  copyFiltersInto(other) {
+    for (const filter of this.requestFilters_) {
+      other.requestFilters_.add(filter);
+    }
+    for (const filter of this.responseFilters_) {
+      other.responseFilters_.add(filter);
+    }
+  }
+
   /**
    * Registers a new request filter.  All filters are applied in the order they
    * are registered.
@@ -450,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,