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