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