Source: lib/polyfill/media_capabilities.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.MediaCapabilities');
  9. goog.require('shaka.log');
  10. goog.require('shaka.polyfill');
  11. goog.require('shaka.util.Platform');
  14. /**
  15.  * @summary A polyfill to provide navigator.mediaCapabilities on all browsers.
  16.  * This is necessary for Tizen 3, Xbox One and possibly others we have yet to
  17.  * discover.
  18.  * @export
  19.  */
  20. shaka.polyfill.MediaCapabilities = class {
  21.   /**
  22.    * Install the polyfill if needed.
  23.    * @suppress {const}
  24.    * @export
  25.    */
  26.   static install() {
  27.     // Since MediaCapabilities is not fully supported on Chromecast yet, we
  28.     // should always install polyfill for Chromecast.
  29.     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
  30.     // Since MediaCapabilities implementation is buggy in Apple browsers, we
  31.     // should always install polyfill for Apple browsers.
  32.     // See: https://github.com/shaka-project/shaka-player/issues/3530
  33.     // TODO: re-evaluate MediaCapabilities in the future versions of Apple
  34.     // Browsers.
  35.     // Since MediaCapabilities implementation is buggy in PS5 browsers, we
  36.     // should always install polyfill for PS5 browsers.
  37.     // See: https://github.com/shaka-project/shaka-player/issues/3582
  38.     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
  39.     // Browsers.
  40.     if (!shaka.util.Platform.isChromecast() &&
  41.         !shaka.util.Platform.isApple() &&
  42.         !shaka.util.Platform.isPS5() &&
  43.         navigator.mediaCapabilities) {
  44.       shaka.log.info(
  45.           'MediaCapabilities: Native mediaCapabilities support found.');
  46.       return;
  47.     }
  49.     shaka.log.info('MediaCapabilities: install');
  51.     if (!navigator.mediaCapabilities) {
  52.       navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
  53.     }
  55.     // Keep the patched MediaCapabilities object from being garbage-collected in
  56.     // Safari.
  57.     // See https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
  58.     shaka.polyfill.MediaCapabilities.originalMcap =
  59.         navigator.mediaCapabilities;
  61.     navigator.mediaCapabilities.decodingInfo =
  62.         shaka.polyfill.MediaCapabilities.decodingInfo_;
  63.   }
  65.   /**
  66.    * @param {!MediaDecodingConfiguration} mediaDecodingConfig
  67.    * @return {!Promise.<!MediaCapabilitiesDecodingInfo>}
  68.    * @private
  69.    */
  70.   static async decodingInfo_(mediaDecodingConfig) {
  71.     const res = {
  72.       supported: false,
  73.       powerEfficient: true,
  74.       smooth: true,
  75.       keySystemAccess: null,
  76.       configuration: mediaDecodingConfig,
  77.     };
  79.     if (!mediaDecodingConfig) {
  80.       return res;
  81.     }
  83.     if (mediaDecodingConfig.type == 'media-source') {
  84.       if (!shaka.util.Platform.supportsMediaSource()) {
  85.         return res;
  86.       }
  87.       // Use 'MediaSource.isTypeSupported' to check if the stream is supported.
  88.       if (mediaDecodingConfig['video']) {
  89.         const contentType = mediaDecodingConfig['video'].contentType;
  90.         const isSupported = MediaSource.isTypeSupported(contentType);
  91.         if (!isSupported) {
  92.           return res;
  93.         }
  94.       }
  96.       if (mediaDecodingConfig['audio']) {
  97.         const contentType = mediaDecodingConfig['audio'].contentType;
  98.         const isSupported = MediaSource.isTypeSupported(contentType);
  99.         if (!isSupported) {
  100.           return res;
  101.         }
  102.       }
  103.     } else if (mediaDecodingConfig.type == 'file') {
  104.       if (mediaDecodingConfig['video']) {
  105.         const contentType = mediaDecodingConfig['video'].contentType;
  106.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  107.         if (!isSupported) {
  108.           return res;
  109.         }
  110.       }
  112.       if (mediaDecodingConfig['audio']) {
  113.         const contentType = mediaDecodingConfig['audio'].contentType;
  114.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  115.         if (!isSupported) {
  116.           return res;
  117.         }
  118.       }
  119.     } else {
  120.       // Otherwise not supported.
  121.       return res;
  122.     }
  124.     if (!mediaDecodingConfig.keySystemConfiguration) {
  125.       // The variant is supported if it's unencrypted.
  126.       res.supported = true;
  127.       return Promise.resolve(res);
  128.     } else {
  129.       // Get the MediaKeySystemAccess for the key system.
  130.       // Convert the MediaDecodingConfiguration object to a
  131.       // MediaKeySystemConfiguration object.
  133.       /** @type {MediaCapabilitiesKeySystemConfiguration} */
  134.       const mediaCapkeySystemConfig =
  135.           mediaDecodingConfig.keySystemConfiguration;
  136.       const audioCapabilities = [];
  137.       const videoCapabilities = [];
  139.       if (mediaCapkeySystemConfig.audio) {
  140.         const capability = {
  141.           robustness: mediaCapkeySystemConfig.audio.robustness || '',
  142.           contentType: mediaDecodingConfig.audio.contentType,
  143.         };
  144.         audioCapabilities.push(capability);
  145.       }
  147.       if (mediaCapkeySystemConfig.video) {
  148.         const capability = {
  149.           robustness: mediaCapkeySystemConfig.video.robustness || '',
  150.           contentType: mediaDecodingConfig.video.contentType,
  151.         };
  152.         videoCapabilities.push(capability);
  153.       }
  155.       /** @type {MediaKeySystemConfiguration} */
  156.       const mediaKeySystemConfig = {
  157.         initDataTypes: [mediaCapkeySystemConfig.initDataType],
  158.         distinctiveIdentifier: mediaCapkeySystemConfig.distinctiveIdentifier,
  159.         persistentState: mediaCapkeySystemConfig.persistentState,
  160.         sessionTypes: mediaCapkeySystemConfig.sessionTypes,
  161.       };
  163.       // Only add the audio video capabilities if they have valid data.
  164.       // Otherwise the query will fail.
  165.       if (audioCapabilities.length) {
  166.         mediaKeySystemConfig.audioCapabilities = audioCapabilities;
  167.       }
  168.       if (videoCapabilities.length) {
  169.         mediaKeySystemConfig.videoCapabilities = videoCapabilities;
  170.       }
  172.       let keySystemAccess;
  173.       try {
  174.         keySystemAccess = await navigator.requestMediaKeySystemAccess(
  175.             mediaCapkeySystemConfig.keySystem, [mediaKeySystemConfig]);
  176.       } catch (e) {
  177.         shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
  178.       }
  180.       if (keySystemAccess) {
  181.         res.supported = true;
  182.         res.keySystemAccess = keySystemAccess;
  183.       }
  184.     }
  186.     return res;
  187.   }
  188. };
  190. /**
  191.  * A copy of the MediaCapabilities instance, to prevent Safari from
  192.  * garbage-collecting the polyfilled method on it.  We make it public and export
  193.  * it to ensure that it is not stripped out by the compiler.
  194.  *
  195.  * @type {MediaCapabilities}
  196.  * @export
  197.  */
  198. shaka.polyfill.MediaCapabilities.originalMcap = null;
  200. // Install at a lower priority than MediaSource polyfill, so that we have
  201. // MediaSource available first.
  202. shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);