Source: lib/polyfill/mediasource.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.MediaSource');
  9. goog.require('shaka.device.DeviceFactory');
  10. goog.require('shaka.device.IDevice');
  11. goog.require('shaka.log');
  12. goog.require('shaka.polyfill');
  13. goog.require('shaka.util.MimeUtils');
  15. /**
  16.  * @summary A polyfill to patch MSE bugs.
  17.  * @export
  18.  */
  19. shaka.polyfill.MediaSource = class {
  20.   /**
  21.    * Install the polyfill if needed.
  22.    * @export
  23.    */
  24.   static install() {
  25.     shaka.log.debug('MediaSource.install');
  27.     // MediaSource bugs are difficult to detect without checking for the
  28.     // affected platform.  SourceBuffer is not always exposed on window, for
  29.     // example, and instances are only accessible after setting up MediaSource
  30.     // on a video element.  Because of this, we use UA detection and other
  31.     // platform detection tricks to decide which patches to install.
  32.     const BrowserEngine = shaka.device.IDevice.BrowserEngine;
  33.     const device = shaka.device.DeviceFactory.getDevice();
  34.     const safariVersion = device.getBrowserEngine() === BrowserEngine.WEBKIT ?
  35.         device.getVersion() : null;
  37.     if (!window.MediaSource && !window.ManagedMediaSource) {
  38.       shaka.log.info('No MSE implementation available.');
  39.     } else if (safariVersion && window.MediaSource) {
  40.       // NOTE:  shaka.Player.isBrowserSupported() has its own restrictions on
  41.       // Safari version.
  42.       if (safariVersion <= 12) {
  43.         shaka.log.info('Patching Safari 8-12 MSE bugs.');
  44.         // Safari 8 does not implement appendWindowEnd.
  45.         // Safari 10 fires spurious 'updateend' events after endOfStream().
  46.         // We do not have patches for these bugs here.
  48.         // Safari 8-12 do not correctly implement abort() on SourceBuffer.
  49.         // Calling abort() before appending a segment causes that segment to be
  50.         // incomplete in the buffer.
  51.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  52.         shaka.polyfill.MediaSource.stubAbort_();
  54.         // If you remove up to a keyframe, Safari 8-12 incorrectly will also
  55.         // remove that keyframe and the content up to the next.
  56.         // Offsetting the end of the removal range seems to help.
  57.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=177884
  58.         shaka.polyfill.MediaSource.patchRemovalRange_();
  59.       } else if (safariVersion <= 15) {
  60.         shaka.log.info('Patching Safari 13 & 14 & 15 MSE bugs.');
  61.         // Safari 13 does not correctly implement abort() on SourceBuffer.
  62.         // Calling abort() before appending a segment causes that segment to be
  63.         // incomplete in the buffer.
  64.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  65.         shaka.polyfill.MediaSource.stubAbort_();
  66.       }
  67.     } else {
  68.       shaka.log.info('Using native MSE as-is.');
  69.     }
  71.     for (const codec of device.rejectCodecs()) {
  72.       shaka.log.info(`Rejecting ${codec}.`);
  73.       shaka.polyfill.MediaSource.rejectCodec_(codec);
  74.     }
  76.     if (window.MediaSource || window.ManagedMediaSource) {
  77.       // TS content is broken on all browsers in general.
  78.       // See https://github.com/shaka-project/shaka-player/issues/4955
  79.       // See https://github.com/shaka-project/shaka-player/issues/5278
  80.       // See https://github.com/shaka-project/shaka-player/issues/6334
  81.       shaka.polyfill.MediaSource.rejectContainer_('mp2t');
  82.     }
  84.     if (window.MediaSource &&
  85.         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
  86.         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
  87.       shaka.log.info('Patching vp09 support queries.');
  88.       // Only the old, deprecated style of VP9 codec strings is supported.
  89.       // This occurs on older smart TVs.
  90.       // Patch isTypeSupported to translate the new strings into the old one.
  91.       shaka.polyfill.MediaSource.patchVp09_();
  92.     }
  93.   }
  95.   /**
  96.    * Stub out abort().  On some buggy MSE implementations, calling abort()
  97.    * causes various problems.
  98.    *
  99.    * @private
  100.    */
  101.   static stubAbort_() {
  102.     /* eslint-disable no-restricted-syntax */
  103.     const addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  104.     MediaSource.prototype.addSourceBuffer = function(...varArgs) {
  105.       const sourceBuffer = addSourceBuffer.apply(this, varArgs);
  106.       sourceBuffer.abort = function() {}; // Stub out for buggy implementations.
  107.       return sourceBuffer;
  108.     };
  109.     /* eslint-enable no-restricted-syntax */
  110.   }
  112.   /**
  113.    * Patch remove().  On Safari 11, if you call remove() to remove the content
  114.    * up to a keyframe, Safari will also remove the keyframe and all of the data
  115.    * up to the next one. For example, if the keyframes are at 0s, 5s, and 10s,
  116.    * and you tried to remove 0s-5s, it would instead remove 0s-10s.
  117.    *
  118.    * Offsetting the end of the range seems to be a usable workaround.
  119.    *
  120.    * @private
  121.    */
  122.   static patchRemovalRange_() {
  123.     // eslint-disable-next-line no-restricted-syntax
  124.     const originalRemove = SourceBuffer.prototype.remove;
  126.     // eslint-disable-next-line no-restricted-syntax
  127.     SourceBuffer.prototype.remove = function(startTime, endTime) {
  128.       // eslint-disable-next-line no-restricted-syntax
  129.       return originalRemove.call(this, startTime, endTime - 0.001);
  130.     };
  131.   }
  133.   /**
  134.    * Patch |MediaSource.isTypeSupported| to always reject |container|. This is
  135.    * used when we know that we are on a platform that does not work well with
  136.    * a given container.
  137.    *
  138.    * @param {string} container
  139.    * @private
  140.    */
  141.   static rejectContainer_(container) {
  142.     if (window.MediaSource) {
  143.       const isTypeSupported =
  144.           // eslint-disable-next-line no-restricted-syntax
  145.           MediaSource.isTypeSupported.bind(MediaSource);
  147.       MediaSource.isTypeSupported = (mimeType) => {
  148.         const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
  149.         return actualContainer != container && isTypeSupported(mimeType);
  150.       };
  151.     }
  153.     if (window.ManagedMediaSource) {
  154.       const isTypeSupportedManaged =
  155.           // eslint-disable-next-line no-restricted-syntax
  156.           ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
  158.       window.ManagedMediaSource.isTypeSupported = (mimeType) => {
  159.         const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
  160.         return actualContainer != container && isTypeSupportedManaged(mimeType);
  161.       };
  162.     }
  163.   }
  165.   /**
  166.    * Patch |MediaSource.isTypeSupported| to always reject |codec|. This is used
  167.    * when we know that we are on a platform that does not work well with a given
  168.    * codec.
  169.    *
  170.    * @param {string} codec
  171.    * @private
  172.    */
  173.   static rejectCodec_(codec) {
  174.     const isTypeSupported =
  175.         // eslint-disable-next-line no-restricted-syntax
  176.         MediaSource.isTypeSupported.bind(MediaSource);
  178.     MediaSource.isTypeSupported = (mimeType) => {
  179.       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  180.       return actualCodec != codec && isTypeSupported(mimeType);
  181.     };
  183.     if (window.ManagedMediaSource) {
  184.       const isTypeSupportedManaged =
  185.           // eslint-disable-next-line no-restricted-syntax
  186.           ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
  188.       window.ManagedMediaSource.isTypeSupported = (mimeType) => {
  189.         const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  190.         return actualCodec != codec && isTypeSupportedManaged(mimeType);
  191.       };
  192.     }
  193.   }
  195.   /**
  196.    * Patch isTypeSupported() to translate vp09 codec strings into vp9, to allow
  197.    * such content to play on older smart TVs.
  198.    *
  199.    * @private
  200.    */
  201.   static patchVp09_() {
  202.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  204.     if (!shaka.device.DeviceFactory.getDevice().supportStandardVP9Checking()) {
  205.       // Don't do this on LG webOS as otherwise it is unable
  206.       // to play vp09 at all.
  207.       return;
  208.     }
  210.     MediaSource.isTypeSupported = (mimeType) => {
  211.       // Split the MIME type into its various parameters.
  212.       const pieces = mimeType.split(/ *; */);
  214.       const codecsIndex =
  215.           pieces.findIndex((piece) => piece.startsWith('codecs='));
  216.       if (codecsIndex < 0) {
  217.         // No codec? Call the original without modifying the MIME type.
  218.         return originalIsTypeSupported(mimeType);
  219.       }
  221.       const codecsParam = pieces[codecsIndex];
  222.       const codecs = codecsParam
  223.           .replace('codecs=', '').replace(/"/g, '').split(/\s*,\s*/);
  225.       const vp09Index = codecs.findIndex(
  226.           (codecName) => codecName.startsWith('vp09'));
  227.       if (vp09Index >= 0) {
  228.         // vp09? Replace it with vp9.
  229.         codecs[vp09Index] = 'vp9';
  230.         pieces[codecsIndex] = 'codecs="' + codecs.join(',') + '"';
  231.         mimeType = pieces.join('; ');
  232.       }
  234.       return originalIsTypeSupported(mimeType);
  235.     };
  236.   }
  237. };
  240. shaka.polyfill.register(shaka.polyfill.MediaSource.install);