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.isPS4() &&
  43.         !shaka.util.Platform.isPS5() &&
  44.         !shaka.util.Platform.isWebOS() &&
  45.         !shaka.util.Platform.isTizen() &&
  46.         !shaka.util.Platform.isEOS() &&
  47.         !shaka.util.Platform.isHisense() &&
  48.         navigator.mediaCapabilities) {
  49.       shaka.log.info(
  50.           'MediaCapabilities: Native mediaCapabilities support found.');
  51.       return;
  52.     }
  54.     shaka.log.info('MediaCapabilities: install');
  56.     if (!navigator.mediaCapabilities) {
  57.       navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
  58.     }
  60.     // Keep the patched MediaCapabilities object from being garbage-collected in
  61.     // Safari.
  62.     // See https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
  63.     shaka.polyfill.MediaCapabilities.originalMcap =
  64.         navigator.mediaCapabilities;
  66.     navigator.mediaCapabilities.decodingInfo =
  67.         shaka.polyfill.MediaCapabilities.decodingInfo_;
  68.   }
  70.   /**
  71.    * @param {!MediaDecodingConfiguration} mediaDecodingConfig
  72.    * @return {!Promise.<!MediaCapabilitiesDecodingInfo>}
  73.    * @private
  74.    */
  75.   static async decodingInfo_(mediaDecodingConfig) {
  76.     const res = {
  77.       supported: false,
  78.       powerEfficient: true,
  79.       smooth: true,
  80.       keySystemAccess: null,
  81.       configuration: mediaDecodingConfig,
  82.     };
  84.     if (!mediaDecodingConfig) {
  85.       return res;
  86.     }
  88.     const videoConfig = mediaDecodingConfig['video'];
  89.     const audioConfig = mediaDecodingConfig['audio'];
  91.     if (mediaDecodingConfig.type == 'media-source') {
  92.       if (!shaka.util.Platform.supportsMediaSource()) {
  93.         return res;
  94.       }
  95.       // Use 'MediaSource.isTypeSupported' to check if the stream is supported.
  96.       // Cast platforms will additionally check canDisplayType(), which
  97.       // accepts extended MIME type parameters.
  98.       // See: https://github.com/shaka-project/shaka-player/issues/4726
  99.       if (videoConfig) {
  100.         let isSupported;
  101.         if (shaka.util.Platform.isChromecast()) {
  102.           isSupported =
  103.               shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
  104.         } else if (shaka.util.Platform.isTizen()) {
  105.           let extendedType = videoConfig.contentType;
  106.           if (videoConfig.width && videoConfig.height) {
  107.             extendedType += `; width=${videoConfig.width}`;
  108.             extendedType += `; height=${videoConfig.height}`;
  109.           }
  110.           if (videoConfig.framerate) {
  111.             extendedType += `; framerate=${videoConfig.framerate}`;
  112.           }
  113.           if (videoConfig.bitrate) {
  114.             extendedType += `; bitrate=${videoConfig.bitrate}`;
  115.           }
  116.           isSupported = MediaSource.isTypeSupported(extendedType);
  117.         } else {
  118.           isSupported = MediaSource.isTypeSupported(videoConfig.contentType);
  119.         }
  120.         if (!isSupported) {
  121.           return res;
  122.         }
  123.       }
  125.       if (audioConfig) {
  126.         const contentType = audioConfig.contentType;
  127.         const isSupported = MediaSource.isTypeSupported(contentType);
  128.         if (!isSupported) {
  129.           return res;
  130.         }
  131.       }
  132.     } else if (mediaDecodingConfig.type == 'file') {
  133.       if (videoConfig) {
  134.         const contentType = videoConfig.contentType;
  135.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  136.         if (!isSupported) {
  137.           return res;
  138.         }
  139.       }
  141.       if (audioConfig) {
  142.         const contentType = audioConfig.contentType;
  143.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  144.         if (!isSupported) {
  145.           return res;
  146.         }
  147.       }
  148.     } else {
  149.       // Otherwise not supported.
  150.       return res;
  151.     }
  153.     if (!mediaDecodingConfig.keySystemConfiguration) {
  154.       // The variant is supported if it's unencrypted.
  155.       res.supported = true;
  156.       return Promise.resolve(res);
  157.     } else {
  158.       // Get the MediaKeySystemAccess for the key system.
  159.       // Convert the MediaDecodingConfiguration object to a
  160.       // MediaKeySystemConfiguration object.
  162.       /** @type {MediaCapabilitiesKeySystemConfiguration} */
  163.       const mediaCapkeySystemConfig =
  164.           mediaDecodingConfig.keySystemConfiguration;
  165.       const audioCapabilities = [];
  166.       const videoCapabilities = [];
  168.       if (mediaCapkeySystemConfig.audio) {
  169.         const capability = {
  170.           robustness: mediaCapkeySystemConfig.audio.robustness || '',
  171.           contentType: mediaDecodingConfig.audio.contentType,
  172.         };
  173.         audioCapabilities.push(capability);
  174.       }
  176.       if (mediaCapkeySystemConfig.video) {
  177.         const capability = {
  178.           robustness: mediaCapkeySystemConfig.video.robustness || '',
  179.           contentType: mediaDecodingConfig.video.contentType,
  180.         };
  181.         videoCapabilities.push(capability);
  182.       }
  184.       /** @type {MediaKeySystemConfiguration} */
  185.       const mediaKeySystemConfig = {
  186.         initDataTypes: [mediaCapkeySystemConfig.initDataType],
  187.         distinctiveIdentifier: mediaCapkeySystemConfig.distinctiveIdentifier,
  188.         persistentState: mediaCapkeySystemConfig.persistentState,
  189.         sessionTypes: mediaCapkeySystemConfig.sessionTypes,
  190.       };
  192.       // Only add the audio video capabilities if they have valid data.
  193.       // Otherwise the query will fail.
  194.       if (audioCapabilities.length) {
  195.         mediaKeySystemConfig.audioCapabilities = audioCapabilities;
  196.       }
  197.       if (videoCapabilities.length) {
  198.         mediaKeySystemConfig.videoCapabilities = videoCapabilities;
  199.       }
  201.       let keySystemAccess;
  202.       try {
  203.         keySystemAccess = await navigator.requestMediaKeySystemAccess(
  204.             mediaCapkeySystemConfig.keySystem, [mediaKeySystemConfig]);
  205.       } catch (e) {
  206.         shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
  207.       }
  209.       if (keySystemAccess) {
  210.         res.supported = true;
  211.         res.keySystemAccess = keySystemAccess;
  212.       }
  213.     }
  215.     return res;
  216.   }
  218.   /**
  219.    * Checks if the given media parameters of the video or audio streams are
  220.    * supported by the Cast platform.
  221.    * @param {!VideoConfiguration} videoConfig The 'video' field of the
  222.    *     MediaDecodingConfiguration.
  223.    * @return {boolean} `true` when the stream can be displayed on a Cast device.
  224.    * @private
  225.    */
  226.   static canCastDisplayType_(videoConfig) {
  227.     if (!(window.cast &&
  228.         cast.__platform__ && cast.__platform__.canDisplayType)) {
  229.       shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
  230.           'MediaSource.isTypeSupported() for type support.');
  231.       return MediaSource.isTypeSupported(videoConfig.contentType);
  232.     }
  234.     let displayType = videoConfig.contentType;
  235.     if (videoConfig.width && videoConfig.height) {
  236.       displayType +=
  237.           `; width=${videoConfig.width}; height=${videoConfig.height}`;
  238.     }
  239.     if (videoConfig.framerate) {
  240.       displayType += `; framerate=${videoConfig.framerate}`;
  241.     }
  242.     if (videoConfig.transferFunction === 'pq') {
  243.       // A "PQ" transfer function indicates this is an HDR-capable stream;
  244.       // "smpte2084" is the published standard. We need to inform the platform
  245.       // this query is specifically for HDR.
  246.       displayType += '; eotf=smpte2084';
  247.     }
  248.     return cast.__platform__.canDisplayType(displayType);
  249.   }
  250. };
  252. /**
  253.  * A copy of the MediaCapabilities instance, to prevent Safari from
  254.  * garbage-collecting the polyfilled method on it.  We make it public and export
  255.  * it to ensure that it is not stripped out by the compiler.
  256.  *
  257.  * @type {MediaCapabilities}
  258.  * @export
  259.  */
  260. shaka.polyfill.MediaCapabilities.originalMcap = null;
  262. // Install at a lower priority than MediaSource polyfill, so that we have
  263. // MediaSource available first.
  264. shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);