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.drm.DrmUtils');
  11. goog.require('shaka.media.Capabilities');
  12. goog.require('shaka.polyfill');
  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.isOlderChromecast() ||
  54.         shaka.util.Platform.isApple() ||
  55.         shaka.util.Platform.isPS5() ||
  56.         shaka.util.Platform.isPS4() ||
  57.         shaka.util.Platform.isWebOS() ||
  58.         shaka.util.Platform.isTizen() ||
  59.         shaka.util.Platform.isHisense() ||
  60.         shaka.util.Platform.isVizio() ||
  61.         shaka.util.Platform.isWebkitSTB()) {
  62.       canUseNativeMCap = false;
  63.     }
  64.     if (canUseNativeMCap && navigator.mediaCapabilities) {
  65.       shaka.log.info(
  66.           'MediaCapabilities: Native mediaCapabilities support found.');
  67.       return;
  68.     }
  70.     shaka.log.info('MediaCapabilities: install');
  72.     if (!navigator.mediaCapabilities) {
  73.       navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
  74.     }
  76.     // Keep the patched MediaCapabilities object from being garbage-collected in
  77.     // Safari. See this issue for details on the garbage-collection:
  78.     // https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
  79.     //
  80.     // Using string notation is very important to avoid the compiler from
  81.     // collapsing the property into a variable. See these two issues for more
  82.     // details:
  83.     // https://github.com/shaka-project/shaka-player/issues/8607
  84.     // https://github.com/vercel/next.js/issues/78438#issuecomment-2879434319
  85.     shaka.polyfill.MediaCapabilities['originalMcap'] =
  86.         navigator.mediaCapabilities;
  88.     navigator.mediaCapabilities.decodingInfo =
  89.         shaka.polyfill.MediaCapabilities.decodingInfo_;
  90.   }
  92.   /**
  93.    * @param {!MediaDecodingConfiguration} mediaDecodingConfig
  94.    * @return {!Promise<!MediaCapabilitiesDecodingInfo>}
  95.    * @private
  96.    */
  97.   static async decodingInfo_(mediaDecodingConfig) {
  98.     /** @type {!MediaCapabilitiesDecodingInfo} */
  99.     const res = {
  100.       supported: false,
  101.       powerEfficient: true,
  102.       smooth: true,
  103.       keySystemAccess: null,
  104.       configuration: mediaDecodingConfig,
  105.     };
  107.     const videoConfig = mediaDecodingConfig['video'];
  108.     const audioConfig = mediaDecodingConfig['audio'];
  110.     if (mediaDecodingConfig.type == 'media-source') {
  111.       if (!shaka.util.Platform.supportsMediaSource()) {
  112.         return res;
  113.       }
  115.       if (videoConfig) {
  116.         const isSupported =
  117.             await shaka.polyfill.MediaCapabilities.checkVideoSupport_(
  118.                 videoConfig);
  119.         if (!isSupported) {
  120.           return res;
  121.         }
  122.       }
  124.       if (audioConfig) {
  125.         const isSupported =
  126.             shaka.polyfill.MediaCapabilities.checkAudioSupport_(audioConfig);
  127.         if (!isSupported) {
  128.           return res;
  129.         }
  130.       }
  131.     } else if (mediaDecodingConfig.type == 'file') {
  132.       if (videoConfig) {
  133.         const contentType = videoConfig.contentType;
  134.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  135.         if (!isSupported) {
  136.           return res;
  137.         }
  138.       }
  140.       if (audioConfig) {
  141.         const contentType = audioConfig.contentType;
  142.         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
  143.         if (!isSupported) {
  144.           return res;
  145.         }
  146.       }
  147.     } else {
  148.       // Otherwise not supported.
  149.       return res;
  150.     }
  152.     if (!mediaDecodingConfig.keySystemConfiguration) {
  153.       // The variant is supported if it's unencrypted.
  154.       res.supported = true;
  155.       return res;
  156.     } else {
  157.       const mcapKeySystemConfig = mediaDecodingConfig.keySystemConfiguration;
  158.       const keySystemAccess =
  159.           await shaka.polyfill.MediaCapabilities.checkDrmSupport_(
  160.               videoConfig, audioConfig, mcapKeySystemConfig);
  161.       if (keySystemAccess) {
  162.         res.supported = true;
  163.         res.keySystemAccess = keySystemAccess;
  164.       }
  165.     }
  167.     return res;
  168.   }
  170.   /**
  171.    * @param {!VideoConfiguration} videoConfig The 'video' field of the
  172.    *   MediaDecodingConfiguration.
  173.    * @return {!Promise<boolean>}
  174.    * @private
  175.    */
  176.   static async checkVideoSupport_(videoConfig) {
  177.     // Use 'shaka.media.Capabilities.isTypeSupported' to check if
  178.     // the stream is supported.
  179.     // Cast platforms will additionally check canDisplayType(), which
  180.     // accepts extended MIME type parameters.
  181.     // See: https://github.com/shaka-project/shaka-player/issues/4726
  182.     if (shaka.util.Platform.isChromecast()) {
  183.       const isSupported =
  184.           await shaka.polyfill.MediaCapabilities.canCastDisplayType_(
  185.               videoConfig);
  186.       return isSupported;
  187.     }
  188.     return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
  189.   }
  191.   /**
  192.    * @param {!AudioConfiguration} audioConfig The 'audio' field of the
  193.    *   MediaDecodingConfiguration.
  194.    * @return {boolean}
  195.    * @private
  196.    */
  197.   static checkAudioSupport_(audioConfig) {
  198.     let extendedType = audioConfig.contentType;
  199.     if (shaka.util.Platform.isChromecast() && audioConfig.spatialRendering) {
  200.       extendedType += '; spatialRendering=true';
  201.     }
  202.     return shaka.media.Capabilities.isTypeSupported(extendedType);
  203.   }
  205.   /**
  206.    * @param {VideoConfiguration} videoConfig The 'video' field of the
  207.    *   MediaDecodingConfiguration.
  208.    * @param {AudioConfiguration} audioConfig The 'audio' field of the
  209.    *   MediaDecodingConfiguration.
  210.    * @param {!MediaCapabilitiesKeySystemConfiguration} mcapKeySystemConfig The
  211.    *   'keySystemConfiguration' field of the MediaDecodingConfiguration.
  212.    * @return {Promise<MediaKeySystemAccess>}
  213.    * @private
  214.    */
  215.   static async checkDrmSupport_(videoConfig, audioConfig, mcapKeySystemConfig) {
  216.     const MimeUtils = shaka.util.MimeUtils;
  217.     const audioCapabilities = [];
  218.     const videoCapabilities = [];
  220.     if (mcapKeySystemConfig.audio) {
  221.       const capability = {
  222.         robustness: mcapKeySystemConfig.audio.robustness || '',
  223.         contentType: audioConfig.contentType,
  224.       };
  226.       // Some Tizen devices seem to misreport AC-3 support, but correctly
  227.       // report EC-3 support. So query EC-3 as a fallback for AC-3.
  228.       // See https://github.com/shaka-project/shaka-player/issues/2989 for
  229.       // details.
  230.       if (shaka.util.Platform.isTizen() &&
  231.           audioConfig.contentType.includes('codecs="ac-3"')) {
  232.         capability.contentType = 'audio/mp4; codecs="ec-3"';
  233.       }
  235.       if (mcapKeySystemConfig.audio.encryptionScheme) {
  236.         capability.encryptionScheme =
  237.             mcapKeySystemConfig.audio.encryptionScheme;
  238.       }
  240.       audioCapabilities.push(capability);
  241.     }
  243.     if (mcapKeySystemConfig.video) {
  244.       const capability = {
  245.         robustness: mcapKeySystemConfig.video.robustness || '',
  246.         contentType: videoConfig.contentType,
  247.       };
  248.       if (mcapKeySystemConfig.video.encryptionScheme) {
  249.         capability.encryptionScheme =
  250.             mcapKeySystemConfig.video.encryptionScheme;
  251.       }
  252.       videoCapabilities.push(capability);
  253.     }
  255.     /** @type {MediaKeySystemConfiguration} */
  256.     const mediaKeySystemConfig = {
  257.       initDataTypes: [mcapKeySystemConfig.initDataType],
  258.       distinctiveIdentifier: mcapKeySystemConfig.distinctiveIdentifier,
  259.       persistentState: mcapKeySystemConfig.persistentState,
  260.       sessionTypes: mcapKeySystemConfig.sessionTypes,
  261.     };
  263.     // Only add audio / video capabilities if they have valid data.
  264.     // Otherwise the query will fail.
  265.     if (audioCapabilities.length) {
  266.       mediaKeySystemConfig.audioCapabilities = audioCapabilities;
  267.     }
  268.     if (videoCapabilities.length) {
  269.       mediaKeySystemConfig.videoCapabilities = videoCapabilities;
  270.     }
  272.     const videoMimeType = videoConfig ? videoConfig.contentType : '';
  273.     const audioMimeType = audioConfig ? audioConfig.contentType : '';
  274.     const videoCodec = MimeUtils.getBasicType(videoMimeType) + ';' +
  275.         MimeUtils.getCodecBase(videoMimeType);
  276.     const audioCodec = MimeUtils.getBasicType(audioMimeType) + ';' +
  277.         MimeUtils.getCodecBase(audioMimeType);
  278.     const keySystem = mcapKeySystemConfig.keySystem;
  280.     /** @type {MediaKeySystemAccess} */
  281.     let keySystemAccess = null;
  282.     try {
  283.       if (shaka.drm.DrmUtils.hasMediaKeySystemAccess(
  284.           videoCodec, audioCodec, keySystem)) {
  285.         keySystemAccess = shaka.drm.DrmUtils.getMediaKeySystemAccess(
  286.             videoCodec, audioCodec, keySystem);
  287.       } else {
  288.         keySystemAccess = await navigator.requestMediaKeySystemAccess(
  289.             mcapKeySystemConfig.keySystem, [mediaKeySystemConfig]);
  290.         shaka.drm.DrmUtils.setMediaKeySystemAccess(
  291.             videoCodec, audioCodec, keySystem, keySystemAccess);
  292.       }
  293.     } catch (e) {
  294.       shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
  295.     }
  297.     return keySystemAccess;
  298.   }
  300.   /**
  301.    * Checks if the given media parameters of the video or audio streams are
  302.    * supported by the Cast platform.
  303.    * @param {!VideoConfiguration} videoConfig The 'video' field of the
  304.    *   MediaDecodingConfiguration.
  305.    * @return {!Promise<boolean>} `true` when the stream can be displayed on a
  306.    *   Cast device.
  307.    * @private
  308.    */
  309.   static async canCastDisplayType_(videoConfig) {
  310.     if (!(window.cast &&
  311.         cast.__platform__ && cast.__platform__.canDisplayType)) {
  312.       shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
  313.           'shaka.media.Capabilities.isTypeSupported() for type support.');
  314.       return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
  315.     }
  317.     let displayType = videoConfig.contentType;
  318.     if (videoConfig.width && videoConfig.height) {
  319.       // All Chromecast can support 720p videos
  320.       if (videoConfig.width > 1280 && videoConfig.height > 720) {
  321.         displayType +=
  322.             `; width=${videoConfig.width}; height=${videoConfig.height}`;
  323.       }
  324.     }
  325.     if (videoConfig.framerate) {
  326.       // All Chromecast can support a framerate of 24, 25 or 30.
  327.       const framerate = Math.round(videoConfig.framerate);
  328.       if (framerate < 24 || framerate > 30) {
  329.         displayType += `; framerate=${videoConfig.framerate}`;
  330.       }
  331.     }
  333.     // Don't trust Closure types here.  Although transferFunction is string or
  334.     // undefined, we don't want to count on the input type.  A switch statement
  335.     // will, however, differentiate between null and undefined.  So we default
  336.     // to a blank string.
  337.     const transferFunction = videoConfig.transferFunction || '';
  339.     // Based on internal sources.  Googlers, see go/cast-hdr-queries for source.
  340.     switch (transferFunction) {
  341.       // The empty case falls through to SDR.
  342.       case '':
  343.       // These are the only 3 values defined by MCap as of November 2024.
  344.       case 'srgb':
  345.         // https://en.wikipedia.org/wiki/Standard-dynamic-range_video
  346.         // https://en.wikipedia.org/wiki/SRGB
  347.         // https://en.wikipedia.org/wiki/Rec._709
  348.         // This is SDR, standardized in BT 709.
  349.         // The platform recognizes "eotf=bt709", but we can also omit it.
  350.         break;
  352.       case 'pq':
  353.         // https://en.wikipedia.org/wiki/Perceptual_quantizer
  354.         // This HDR transfer function is standardized as SMPTE ST 2084.
  355.         displayType += '; eotf=smpte2084';
  356.         break;
  358.       case 'hlg':
  359.         // https://en.wikipedia.org/wiki/Hybrid_log%E2%80%93gamma
  360.         // This HDR transfer function is standardized as ARIB STD-B67.
  361.         displayType += '; eotf=arib-std-b67';
  362.         break;
  364.       default:
  365.         // An unrecognized transfer function.  Reject this query.
  366.         return false;
  367.     }
  369.     let result = false;
  370.     const memoizedCanDisplayTypeRequests =
  371.         shaka.polyfill.MediaCapabilities.memoizedCanDisplayTypeRequests_;
  372.     if (memoizedCanDisplayTypeRequests.has(displayType)) {
  373.       result = memoizedCanDisplayTypeRequests.get(displayType);
  374.     } else {
  375.       result = await cast.__platform__.canDisplayType(displayType);
  376.       memoizedCanDisplayTypeRequests.set(displayType, result);
  377.     }
  378.     return result;
  379.   }
  380. };
  382. /**
  383.  * A copy of the MediaCapabilities instance, to prevent Safari from
  384.  * garbage-collecting the polyfilled method on it. We make it public and export
  385.  * it to ensure that it is not stripped out by the compiler.
  386.  *
  387.  * @type {MediaCapabilities}
  388.  * @export
  389.  */
  390. shaka.polyfill.MediaCapabilities.originalMcap = null;
  392. /**
  393.  * A cache that stores the canDisplayType result of calling
  394.  * `cast.__platform__.canDisplayType`.
  395.  *
  396.  * @type {Map<string, boolean>}
  397.  * @private
  398.  */
  399. shaka.polyfill.MediaCapabilities.memoizedCanDisplayTypeRequests_ = new Map();
  401. // Install at a lower priority than MediaSource polyfill, so that we have
  402. // MediaSource available first.
  403. shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);