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.log');
  10. goog.require('shaka.polyfill');
  11. goog.require('shaka.util.MimeUtils');
  12. goog.require('shaka.util.Platform');
  14. /**
  15.  * @summary A polyfill to patch MSE bugs.
  16.  * @export
  17.  */
  18. shaka.polyfill.MediaSource = class {
  19.   /**
  20.    * Install the polyfill if needed.
  21.    * @export
  22.    */
  23.   static install() {
  24.     shaka.log.debug('MediaSource.install');
  26.     // MediaSource bugs are difficult to detect without checking for the
  27.     // affected platform.  SourceBuffer is not always exposed on window, for
  28.     // example, and instances are only accessible after setting up MediaSource
  29.     // on a video element.  Because of this, we use UA detection and other
  30.     // platform detection tricks to decide which patches to install.
  31.     const safariVersion = shaka.util.Platform.safariVersion();
  33.     if (!window.MediaSource && !window.ManagedMediaSource) {
  34.       shaka.log.info('No MSE implementation available.');
  35.     } else if (safariVersion && window.MediaSource) {
  36.       // NOTE:  shaka.Player.isBrowserSupported() has its own restrictions on
  37.       // Safari version.
  38.       if (safariVersion <= 10) {
  39.         // Safari 8 does not implement appendWindowEnd.
  40.         // Safari 9 & 10 do not correctly implement abort() on SourceBuffer.
  41.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=160316
  42.         // Blacklist these very outdated versions.
  43.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  44.         // Safari 10 fires spurious 'updateend' events after endOfStream().
  45.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165336
  47.         shaka.log.info('Blacklisting MSE on Safari <= 10.');
  48.         shaka.polyfill.MediaSource.blacklist_();
  49.       } else if (safariVersion <= 12) {
  50.         shaka.log.info('Patching Safari 11 & 12 MSE bugs.');
  51.         // Safari 11 & 12 do not correctly implement abort() on SourceBuffer.
  52.         // Calling abort() before appending a segment causes that segment to be
  53.         // incomplete in the buffer.
  54.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  55.         shaka.polyfill.MediaSource.stubAbort_();
  57.         // If you remove up to a keyframe, Safari 11 & 12 incorrectly will also
  58.         // remove that keyframe and the content up to the next.
  59.         // Offsetting the end of the removal range seems to help.
  60.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=177884
  61.         shaka.polyfill.MediaSource.patchRemovalRange_();
  62.       } else if (safariVersion <= 15) {
  63.         shaka.log.info('Patching Safari 13 & 14 & 15 MSE bugs.');
  64.         // Safari 13 does not correctly implement abort() on SourceBuffer.
  65.         // Calling abort() before appending a segment causes that segment to be
  66.         // incomplete in the buffer.
  67.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  68.         shaka.polyfill.MediaSource.stubAbort_();
  69.       }
  70.     } else if (shaka.util.Platform.isZenterio()) {
  71.       // Zenterio uses WPE based on Webkit 607.x.x which do not correctly
  72.       // implement abort() on SourceBuffer.
  73.       // Calling abort() before appending a segment causes that segment to be
  74.       // incomplete in the buffer.
  75.       // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  76.       shaka.polyfill.MediaSource.stubAbort_();
  77.       // If you remove up to a keyframe, Webkit 607.x.x incorrectly will also
  78.       // remove that keyframe and the content up to the next.
  79.       // Offsetting the end of the removal range seems to help.
  80.       // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=177884
  81.       shaka.polyfill.MediaSource.patchRemovalRange_();
  82.     } else if (shaka.util.Platform.isTizen2() ||
  83.         shaka.util.Platform.isTizen3() ||
  84.         shaka.util.Platform.isTizen4()) {
  85.       shaka.log.info('Rejecting Opus.');
  86.       // Tizen's implementation of MSE does not work well with opus. To prevent
  87.       // the player from trying to play opus on Tizen, we will override media
  88.       // source to always reject opus content.
  89.       shaka.polyfill.MediaSource.rejectCodec_('opus');
  90.     } else if (shaka.util.Platform.isComcastX1()) {
  91.       // XOne look to be like safari 8 which do not correctly
  92.       // implement abort() on SourceBuffer.
  93.       // Calling abort() before appending a segment causes that segment to be
  94.       // incomplete in the buffer.
  95.       // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  96.       shaka.polyfill.MediaSource.stubAbort_();
  97.       // If you remove up to a keyframe, Webkit 601.x.x incorrectly will also
  98.       // remove that keyframe and the content up to the next.
  99.       // Offsetting the end of the removal range seems to help.
  100.       // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=177884
  101.       shaka.polyfill.MediaSource.patchRemovalRange_();
  102.     } else {
  103.       shaka.log.info('Using native MSE as-is.');
  104.     }
  106.     if (window.MediaSource || window.ManagedMediaSource) {
  107.       // TS content is broken on all browsers in general.
  108.       // See https://github.com/shaka-project/shaka-player/issues/4955
  109.       // See https://github.com/shaka-project/shaka-player/issues/5278
  110.       // See https://github.com/shaka-project/shaka-player/issues/6334
  111.       shaka.polyfill.MediaSource.rejectContainer_('mp2t');
  112.     }
  114.     if (window.MediaSource &&
  115.         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
  116.         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
  117.       shaka.log.info('Patching vp09 support queries.');
  118.       // Only the old, deprecated style of VP9 codec strings is supported.
  119.       // This occurs on older smart TVs.
  120.       // Patch isTypeSupported to translate the new strings into the old one.
  121.       shaka.polyfill.MediaSource.patchVp09_();
  122.     }
  123.   }
  125.   /**
  126.    * Blacklist the current browser by making
  127.    * MediaSourceEngine.isBrowserSupported fail later.
  128.    *
  129.    * @private
  130.    */
  131.   static blacklist_() {
  132.     window['MediaSource'] = null;
  133.   }
  135.   /**
  136.    * Stub out abort().  On some buggy MSE implementations, calling abort()
  137.    * causes various problems.
  138.    *
  139.    * @private
  140.    */
  141.   static stubAbort_() {
  142.     /* eslint-disable no-restricted-syntax */
  143.     const addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  144.     MediaSource.prototype.addSourceBuffer = function(...varArgs) {
  145.       const sourceBuffer = addSourceBuffer.apply(this, varArgs);
  146.       sourceBuffer.abort = function() {}; // Stub out for buggy implementations.
  147.       return sourceBuffer;
  148.     };
  149.     /* eslint-enable no-restricted-syntax */
  150.   }
  152.   /**
  153.    * Patch remove().  On Safari 11, if you call remove() to remove the content
  154.    * up to a keyframe, Safari will also remove the keyframe and all of the data
  155.    * up to the next one. For example, if the keyframes are at 0s, 5s, and 10s,
  156.    * and you tried to remove 0s-5s, it would instead remove 0s-10s.
  157.    *
  158.    * Offsetting the end of the range seems to be a usable workaround.
  159.    *
  160.    * @private
  161.    */
  162.   static patchRemovalRange_() {
  163.     // eslint-disable-next-line no-restricted-syntax
  164.     const originalRemove = SourceBuffer.prototype.remove;
  166.     // eslint-disable-next-line no-restricted-syntax
  167.     SourceBuffer.prototype.remove = function(startTime, endTime) {
  168.       // eslint-disable-next-line no-restricted-syntax
  169.       return originalRemove.call(this, startTime, endTime - 0.001);
  170.     };
  171.   }
  173.   /**
  174.    * Patch |MediaSource.isTypeSupported| to always reject |container|. This is
  175.    * used when we know that we are on a platform that does not work well with
  176.    * a given container.
  177.    *
  178.    * @param {string} container
  179.    * @private
  180.    */
  181.   static rejectContainer_(container) {
  182.     if (window.MediaSource) {
  183.       const isTypeSupported =
  184.           // eslint-disable-next-line no-restricted-syntax
  185.           MediaSource.isTypeSupported.bind(MediaSource);
  187.       MediaSource.isTypeSupported = (mimeType) => {
  188.         const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
  189.         return actualContainer != container && isTypeSupported(mimeType);
  190.       };
  191.     }
  193.     if (window.ManagedMediaSource) {
  194.       const isTypeSupportedManaged =
  195.           // eslint-disable-next-line no-restricted-syntax
  196.           ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
  198.       window.ManagedMediaSource.isTypeSupported = (mimeType) => {
  199.         const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
  200.         return actualContainer != container && isTypeSupportedManaged(mimeType);
  201.       };
  202.     }
  203.   }
  205.   /**
  206.    * Patch |MediaSource.isTypeSupported| to always reject |codec|. This is used
  207.    * when we know that we are on a platform that does not work well with a given
  208.    * codec.
  209.    *
  210.    * @param {string} codec
  211.    * @private
  212.    */
  213.   static rejectCodec_(codec) {
  214.     const isTypeSupported =
  215.         // eslint-disable-next-line no-restricted-syntax
  216.         MediaSource.isTypeSupported.bind(MediaSource);
  218.     MediaSource.isTypeSupported = (mimeType) => {
  219.       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  220.       return actualCodec != codec && isTypeSupported(mimeType);
  221.     };
  223.     if (window.ManagedMediaSource) {
  224.       const isTypeSupportedManaged =
  225.           // eslint-disable-next-line no-restricted-syntax
  226.           ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
  228.       window.ManagedMediaSource.isTypeSupported = (mimeType) => {
  229.         const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  230.         return actualCodec != codec && isTypeSupportedManaged(mimeType);
  231.       };
  232.     }
  233.   }
  235.   /**
  236.    * Patch isTypeSupported() to translate vp09 codec strings into vp9, to allow
  237.    * such content to play on older smart TVs.
  238.    *
  239.    * @private
  240.    */
  241.   static patchVp09_() {
  242.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  244.     if (shaka.util.Platform.isWebOS()) {
  245.       // Don't do this on LG webOS as otherwise it is unable
  246.       // to play vp09 at all.
  247.       return;
  248.     }
  250.     MediaSource.isTypeSupported = (mimeType) => {
  251.       // Split the MIME type into its various parameters.
  252.       const pieces = mimeType.split(/ *; */);
  254.       const codecsIndex =
  255.           pieces.findIndex((piece) => piece.startsWith('codecs='));
  256.       if (codecsIndex < 0) {
  257.         // No codec? Call the original without modifying the MIME type.
  258.         return originalIsTypeSupported(mimeType);
  259.       }
  261.       const codecsParam = pieces[codecsIndex];
  262.       const codecs = codecsParam
  263.           .replace('codecs=', '').replace(/"/g, '').split(/\s*,\s*/);
  265.       const vp09Index = codecs.findIndex(
  266.           (codecName) => codecName.startsWith('vp09'));
  267.       if (vp09Index >= 0) {
  268.         // vp09? Replace it with vp9.
  269.         codecs[vp09Index] = 'vp9';
  270.         pieces[codecsIndex] = 'codecs="' + codecs.join(',') + '"';
  271.         mimeType = pieces.join('; ');
  272.       }
  274.       return originalIsTypeSupported(mimeType);
  275.     };
  276.   }
  277. };
  280. shaka.polyfill.register(shaka.polyfill.MediaSource.install);