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