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.media.Capabilities');
  11. goog.require('shaka.polyfill');
  12. goog.require('shaka.util.DrmUtils');
  13. goog.require('shaka.util.Platform');
  16. /**
  17.  * @summary A polyfill to provide navigator.mediaCapabilities on all browsers.
  18.  * This is necessary for Tizen 3, Xbox One and possibly others we have yet to
  19.  * discover.
  20.  * @export
  21.  */
  22. shaka.polyfill.MediaCapabilities = class {
  23.   /**
  24.    * Install the polyfill if needed.
  25.    * @suppress {const}
  26.    * @export
  27.    */
  28.   static install() {
  29.     // We can enable MediaCapabilities in Android and Fuchsia devices, but not
  30.     // in Linux devices because the implementation is buggy.
  31.     // Since MediaCapabilities implementation is buggy in Apple browsers, we
  32.     // should always install polyfill for Apple browsers.
  33.     // See: https://github.com/shaka-project/shaka-player/issues/3530
  34.     // TODO: re-evaluate MediaCapabilities in the future versions of Apple
  35.     // Browsers.
  36.     // Since MediaCapabilities implementation is buggy in PS5 browsers, we
  37.     // should always install polyfill for PS5 browsers.
  38.     // See: https://github.com/shaka-project/shaka-player/issues/3582
  39.     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
  40.     // Browsers.
  41.     // Since MediaCapabilities implementation does not exist in PS4 browsers, we
  42.     // should always install polyfill.
  43.     // Since MediaCapabilities implementation is buggy in Tizen browsers, we
  44.     // should always install polyfill for Tizen browsers.
  45.     // Since MediaCapabilities implementation is buggy in WebOS browsers, we
  46.     // should always install polyfill for WebOS browsers.
  47.     // Since MediaCapabilities implementation is buggy in EOS browsers, we
  48.     // should always install polyfill for EOS browsers.
  49.     // Since MediaCapabilities implementation is buggy in Hisense browsers, we
  50.     // should always install polyfill for Hisense browsers.
  51.     let canUseNativeMCap = true;
  52.     if (shaka.util.Platform.isChromecast() &&
  53.         !shaka.util.Platform.isAndroidCastDevice() &&
  54.         !shaka.util.Platform.isFuchsiaCastDevice()) {
  55.       canUseNativeMCap = false;
  56.     }
  57.     if (shaka.util.Platform.isApple() ||
  58.         shaka.util.Platform.isPS5() ||
  59.         shaka.util.Platform.isPS4() ||
  60.         shaka.util.Platform.isWebOS() ||
  61.         shaka.util.Platform.isTizen() ||
  62.         shaka.util.Platform.isEOS() ||
  63.         shaka.util.Platform.isHisense()) {
  64.       canUseNativeMCap = false;
  65.     }
  66.     if (canUseNativeMCap && navigator.mediaCapabilities) {
  67.       shaka.log.info(
  68.           'MediaCapabilities: Native mediaCapabilities support found.');
  69.       return;
  70.     }
  72.     shaka.log.info('MediaCapabilities: install');
  74.     if (!navigator.mediaCapabilities) {
  75.       navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
  76.     }
  78.     // Keep the patched MediaCapabilities object from being garbage-collected in
  79.     // Safari.
  80.     // See https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
  81.     shaka.polyfill.MediaCapabilities.originalMcap =
  82.         navigator.mediaCapabilities;
  84.     navigator.mediaCapabilities.decodingInfo =
  85.         shaka.polyfill.MediaCapabilities.decodingInfo_;
  86.   }
  88.   /**
  89.    * @param {!MediaDecodingConfiguration} mediaDecodingConfig
  90.    * @return {!Promise.<!MediaCapabilitiesDecodingInfo>}
  91.    * @private
  92.    */
  93.   static async decodingInfo_(mediaDecodingConfig) {
  94.     /** @type {!MediaCapabilitiesDecodingInfo} */
  95.     const res = {
  96.       supported: false,
  97.       powerEfficient: true,
  98.       smooth: true,
  99.       keySystemAccess: null,
  100.       configuration: mediaDecodingConfig,
  101.     };
  103.     const videoConfig = mediaDecodingConfig['video'];
  104.     const audioConfig = mediaDecodingConfig['audio'];
  106.     if (mediaDecodingConfig.type == 'media-source') {
  107.       if (!shaka.util.Platform.supportsMediaSource()) {
  108.         return res;
  109.       }
  111.       if (videoConfig) {
  112.         const isSupported =
  113.             await shaka.polyfill.MediaCapabilities.checkVideoSupport_(
  114.                 videoConfig);
  115.         if (!isSupported) {
  116.           return res;
  117.         }
  118.       }
  120.       if (audioConfig) {
  121.         const isSupported =
  122.             shaka.polyfill.MediaCapabilities.checkAudioSupport_(audioConfig);
  123.         if (!isSupported) {
  124.           return res;
  125.         }
  126.       }
  127.     } else if (mediaDecodingConfig.type == 'file') {
  128.       if (videoConfig) {
  129.         const contentType = videoConfig.contentType;
  130.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  131.         if (!isSupported) {
  132.           return res;
  133.         }
  134.       }
  136.       if (audioConfig) {
  137.         const contentType = audioConfig.contentType;
  138.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  139.         if (!isSupported) {
  140.           return res;
  141.         }
  142.       }
  143.     } else {
  144.       // Otherwise not supported.
  145.       return res;
  146.     }
  148.     if (!mediaDecodingConfig.keySystemConfiguration) {
  149.       // The variant is supported if it's unencrypted.
  150.       res.supported = true;
  151.       return res;
  152.     } else {
  153.       const mcapKeySystemConfig = mediaDecodingConfig.keySystemConfiguration;
  154.       const keySystemAccess =
  155.           await shaka.polyfill.MediaCapabilities.checkDrmSupport_(
  156.               videoConfig, audioConfig, mcapKeySystemConfig);
  157.       if (keySystemAccess) {
  158.         res.supported = true;
  159.         res.keySystemAccess = keySystemAccess;
  160.       }
  161.     }
  163.     return res;
  164.   }
  166.   /**
  167.    * @param {!VideoConfiguration} videoConfig The 'video' field of the
  168.    *   MediaDecodingConfiguration.
  169.    * @return {!Promise<boolean>}
  170.    * @private
  171.    */
  172.   static async checkVideoSupport_(videoConfig) {
  173.     // Use 'shaka.media.Capabilities.isTypeSupported' to check if
  174.     // the stream is supported.
  175.     // Cast platforms will additionally check canDisplayType(), which
  176.     // accepts extended MIME type parameters.
  177.     // See: https://github.com/shaka-project/shaka-player/issues/4726
  178.     if (shaka.util.Platform.isChromecast()) {
  179.       const isSupported =
  180.           await shaka.polyfill.MediaCapabilities.canCastDisplayType_(
  181.               videoConfig);
  182.       return isSupported;
  183.     } else if (shaka.util.Platform.isTizen()) {
  184.       let extendedType = videoConfig.contentType;
  185.       if (videoConfig.width && videoConfig.height) {
  186.         extendedType += `; width=${videoConfig.width}`;
  187.         extendedType += `; height=${videoConfig.height}`;
  188.       }
  189.       if (videoConfig.framerate) {
  190.         extendedType += `; framerate=${videoConfig.framerate}`;
  191.       }
  192.       if (videoConfig.bitrate) {
  193.         extendedType += `; bitrate=${videoConfig.bitrate}`;
  194.       }
  195.       return shaka.media.Capabilities.isTypeSupported(extendedType);
  196.     }
  197.     return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
  198.   }
  200.   /**
  201.    * @param {!AudioConfiguration} audioConfig The 'audio' field of the
  202.    *   MediaDecodingConfiguration.
  203.    * @return {boolean}
  204.    * @private
  205.    */
  206.   static checkAudioSupport_(audioConfig) {
  207.     let extendedType = audioConfig.contentType;
  208.     if (shaka.util.Platform.isChromecast() && audioConfig.spatialRendering) {
  209.       extendedType += '; spatialRendering=true';
  210.     }
  211.     return shaka.media.Capabilities.isTypeSupported(extendedType);
  212.   }
  214.   /**
  215.    * @param {VideoConfiguration} videoConfig The 'video' field of the
  216.    *   MediaDecodingConfiguration.
  217.    * @param {AudioConfiguration} audioConfig The 'audio' field of the
  218.    *   MediaDecodingConfiguration.
  219.    * @param {!MediaCapabilitiesKeySystemConfiguration} mcapKeySystemConfig The
  220.    *   'keySystemConfiguration' field of the MediaDecodingConfiguration.
  221.    * @return {Promise<MediaKeySystemAccess>}
  222.    * @private
  223.    */
  224.   static async checkDrmSupport_(videoConfig, audioConfig, mcapKeySystemConfig) {
  225.     const audioCapabilities = [];
  226.     const videoCapabilities = [];
  228.     if (mcapKeySystemConfig.audio) {
  229.       const capability = {
  230.         robustness: mcapKeySystemConfig.audio.robustness || '',
  231.         contentType: audioConfig.contentType,
  232.       };
  234.       // Some Tizen devices seem to misreport AC-3 support, but correctly
  235.       // report EC-3 support. So query EC-3 as a fallback for AC-3.
  236.       // See https://github.com/shaka-project/shaka-player/issues/2989 for
  237.       // details.
  238.       if (shaka.util.Platform.isTizen() &&
  239.           audioConfig.contentType.includes('codecs="ac-3"')) {
  240.         capability.contentType = 'audio/mp4; codecs="ec-3"';
  241.       }
  243.       if (mcapKeySystemConfig.audio.encryptionScheme) {
  244.         capability.encryptionScheme =
  245.             mcapKeySystemConfig.audio.encryptionScheme;
  246.       }
  248.       audioCapabilities.push(capability);
  249.     }
  251.     if (mcapKeySystemConfig.video) {
  252.       const capability = {
  253.         robustness: mcapKeySystemConfig.video.robustness || '',
  254.         contentType: videoConfig.contentType,
  255.       };
  256.       if (mcapKeySystemConfig.video.encryptionScheme) {
  257.         capability.encryptionScheme =
  258.             mcapKeySystemConfig.video.encryptionScheme;
  259.       }
  260.       videoCapabilities.push(capability);
  261.     }
  263.     /** @type {MediaKeySystemConfiguration} */
  264.     const mediaKeySystemConfig = {
  265.       initDataTypes: [mcapKeySystemConfig.initDataType],
  266.       distinctiveIdentifier: mcapKeySystemConfig.distinctiveIdentifier,
  267.       persistentState: mcapKeySystemConfig.persistentState,
  268.       sessionTypes: mcapKeySystemConfig.sessionTypes,
  269.     };
  271.     // Only add audio / video capabilities if they have valid data.
  272.     // Otherwise the query will fail.
  273.     if (audioCapabilities.length) {
  274.       mediaKeySystemConfig.audioCapabilities = audioCapabilities;
  275.     }
  276.     if (videoCapabilities.length) {
  277.       mediaKeySystemConfig.videoCapabilities = videoCapabilities;
  278.     }
  280.     const videoCodec = videoConfig ? videoConfig.contentType : '';
  281.     const audioCodec = audioConfig ? audioConfig.contentType : '';
  282.     const keySystem = mcapKeySystemConfig.keySystem;
  284.     /** @type {MediaKeySystemAccess} */
  285.     let keySystemAccess = null;
  286.     try {
  287.       if (shaka.util.DrmUtils.hasMediaKeySystemAccess(
  288.           videoCodec, audioCodec, keySystem)) {
  289.         keySystemAccess = shaka.util.DrmUtils.getMediaKeySystemAccess(
  290.             videoCodec, audioCodec, keySystem);
  291.       } else {
  292.         keySystemAccess = await navigator.requestMediaKeySystemAccess(
  293.             mcapKeySystemConfig.keySystem, [mediaKeySystemConfig]);
  294.         shaka.util.DrmUtils.setMediaKeySystemAccess(
  295.             videoCodec, audioCodec, keySystem, keySystemAccess);
  296.       }
  297.     } catch (e) {
  298.       shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
  299.     }
  301.     return keySystemAccess;
  302.   }
  304.   /**
  305.    * Checks if the given media parameters of the video or audio streams are
  306.    * supported by the Cast platform.
  307.    * @param {!VideoConfiguration} videoConfig The 'video' field of the
  308.    *   MediaDecodingConfiguration.
  309.    * @return {!Promise<boolean>} `true` when the stream can be displayed on a
  310.    *   Cast device.
  311.    * @private
  312.    */
  313.   static async canCastDisplayType_(videoConfig) {
  314.     if (!(window.cast &&
  315.         cast.__platform__ && cast.__platform__.canDisplayType)) {
  316.       shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
  317.           'shaka.media.Capabilities.isTypeSupported() for type support.');
  318.       return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
  319.     }
  321.     let displayType = videoConfig.contentType;
  322.     if (videoConfig.width && videoConfig.height) {
  323.       displayType +=
  324.           `; width=${videoConfig.width}; height=${videoConfig.height}`;
  325.     }
  326.     if (videoConfig.framerate) {
  327.       displayType += `; framerate=${videoConfig.framerate}`;
  328.     }
  329.     if (videoConfig.transferFunction === 'pq') {
  330.       // A "PQ" transfer function indicates this is an HDR-capable stream;
  331.       // "smpte2084" is the published standard. We need to inform the platform
  332.       // this query is specifically for HDR.
  333.       displayType += '; eotf=smpte2084';
  334.     }
  335.     let result = false;
  336.     if (displayType in shaka.polyfill.MediaCapabilities
  337.         .memoizedCanDisplayTypeRequests_) {
  338.       result = shaka.polyfill.MediaCapabilities
  339.           .memoizedCanDisplayTypeRequests_[displayType];
  340.     } else {
  341.       result = await cast.__platform__.canDisplayType(displayType);
  342.       shaka.polyfill.MediaCapabilities
  343.           .memoizedCanDisplayTypeRequests_[displayType] = result;
  344.     }
  345.     return result;
  346.   }
  347. };
  349. /**
  350.  * A copy of the MediaCapabilities instance, to prevent Safari from
  351.  * garbage-collecting the polyfilled method on it. We make it public and export
  352.  * it to ensure that it is not stripped out by the compiler.
  353.  *
  354.  * @type {MediaCapabilities}
  355.  * @export
  356.  */
  357. shaka.polyfill.MediaCapabilities.originalMcap = null;
  359. /**
  360.  * A cache that stores the canDisplayType result of calling
  361.  * `cast.__platform__.canDisplayType`.
  362.  *
  363.  * @type {(Object<(!string), (!boolean)>)}
  364.  * @export
  365.  */
  366. shaka.polyfill.MediaCapabilities.memoizedCanDisplayTypeRequests_ = {};
  368. // Install at a lower priority than MediaSource polyfill, so that we have
  369. // MediaSource available first.
  370. shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);