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