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) {
  34.       shaka.log.info('No MSE implementation available.');
  35.     } else if (window.cast && cast.__platform__ &&
  36.                cast.__platform__.canDisplayType) {
  37.       shaka.log.info('Patching Chromecast MSE bugs.');
  38.       // Chromecast cannot make accurate determinations via isTypeSupported.
  39.       shaka.polyfill.MediaSource.patchCastIsTypeSupported_();
  40.     } else if (safariVersion) {
  41.       // NOTE:  shaka.Player.isBrowserSupported() has its own restrictions on
  42.       // Safari version.
  43.       if (safariVersion <= 12) {
  44.         shaka.log.info('Patching Safari 11 & 12 MSE bugs.');
  45.         // Safari 11 & 12 do not correctly implement abort() on SourceBuffer.
  46.         // Calling abort() before appending a segment causes that segment to be
  47.         // incomplete in the buffer.
  48.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  49.         shaka.polyfill.MediaSource.stubAbort_();
  51.         // If you remove up to a keyframe, Safari 11 & 12 incorrectly will also
  52.         // remove that keyframe and the content up to the next.
  53.         // Offsetting the end of the removal range seems to help.
  54.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=177884
  55.         shaka.polyfill.MediaSource.patchRemovalRange_();
  56.       } else if (safariVersion <= 15) {
  57.         shaka.log.info('Patching Safari 13 & 14 & 15 MSE bugs.');
  58.         // Safari 13 does not correctly implement abort() on SourceBuffer.
  59.         // Calling abort() before appending a segment causes that segment to be
  60.         // incomplete in the buffer.
  61.         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
  62.         shaka.polyfill.MediaSource.stubAbort_();
  63.       }
  64.     } else if (shaka.util.Platform.isEdge()) {
  65.       shaka.log.info('Rejecting TS container.');
  66.       // TS content is broken on Edge in general.
  67.       // See https://github.com/shaka-project/shaka-player/issues/4955
  68.       shaka.polyfill.MediaSource.rejectContainer_('mp2t');
  69.     } else if (shaka.util.Platform.isTizen2() ||
  70.         shaka.util.Platform.isTizen3() ||
  71.         shaka.util.Platform.isTizen4()) {
  72.       shaka.log.info('Rejecting Opus.');
  73.       // Tizen's implementation of MSE does not work well with opus. To prevent
  74.       // the player from trying to play opus on Tizen, we will override media
  75.       // source to always reject opus content.
  76.       shaka.polyfill.MediaSource.rejectCodec_('opus');
  77.     } else {
  78.       shaka.log.info('Using native MSE as-is.');
  79.     }
  81.     if (window.MediaSource &&
  82.         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
  83.         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
  84.       shaka.log.info('Patching vp09 support queries.');
  85.       // Only the old, deprecated style of VP9 codec strings is supported.
  86.       // This occurs on older smart TVs.
  87.       // Patch isTypeSupported to translate the new strings into the old one.
  88.       shaka.polyfill.MediaSource.patchVp09_();
  89.     }
  90.   }
  92.   /**
  93.    * Stub out abort().  On some buggy MSE implementations, calling abort()
  94.    * causes various problems.
  95.    *
  96.    * @private
  97.    */
  98.   static stubAbort_() {
  99.     /* eslint-disable no-restricted-syntax */
  100.     const addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  101.     MediaSource.prototype.addSourceBuffer = function(...varArgs) {
  102.       const sourceBuffer = addSourceBuffer.apply(this, varArgs);
  103.       sourceBuffer.abort = function() {}; // Stub out for buggy implementations.
  104.       return sourceBuffer;
  105.     };
  106.     /* eslint-enable no-restricted-syntax */
  107.   }
  109.   /**
  110.    * Patch remove().  On Safari 11, if you call remove() to remove the content
  111.    * up to a keyframe, Safari will also remove the keyframe and all of the data
  112.    * up to the next one. For example, if the keyframes are at 0s, 5s, and 10s,
  113.    * and you tried to remove 0s-5s, it would instead remove 0s-10s.
  114.    *
  115.    * Offsetting the end of the range seems to be a usable workaround.
  116.    *
  117.    * @private
  118.    */
  119.   static patchRemovalRange_() {
  120.     // eslint-disable-next-line no-restricted-syntax
  121.     const originalRemove = SourceBuffer.prototype.remove;
  123.     // eslint-disable-next-line no-restricted-syntax
  124.     SourceBuffer.prototype.remove = function(startTime, endTime) {
  125.       // eslint-disable-next-line no-restricted-syntax
  126.       return originalRemove.call(this, startTime, endTime - 0.001);
  127.     };
  128.   }
  130.   /**
  131.    * Patch |MediaSource.isTypeSupported| to always reject |container|. This is
  132.    * used when we know that we are on a platform that does not work well with
  133.    * a given container.
  134.    *
  135.    * @param {string} container
  136.    * @private
  137.    */
  138.   static rejectContainer_(container) {
  139.     const isTypeSupported = MediaSource.isTypeSupported;
  141.     MediaSource.isTypeSupported = (mimeType) => {
  142.       const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
  143.       return actualContainer != container && isTypeSupported(mimeType);
  144.     };
  145.   }
  147.   /**
  148.    * Patch |MediaSource.isTypeSupported| to always reject |codec|. This is used
  149.    * when we know that we are on a platform that does not work well with a given
  150.    * codec.
  151.    *
  152.    * @param {string} codec
  153.    * @private
  154.    */
  155.   static rejectCodec_(codec) {
  156.     const isTypeSupported = MediaSource.isTypeSupported;
  158.     MediaSource.isTypeSupported = (mimeType) => {
  159.       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  160.       return actualCodec != codec && isTypeSupported(mimeType);
  161.     };
  162.   }
  164.   /**
  165.    * Patch isTypeSupported() to chain to a private API on the Chromecast which
  166.    * can query for support of detailed content parameters.
  167.    *
  168.    * @private
  169.    */
  170.   static patchCastIsTypeSupported_() {
  171.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  173.     MediaSource.isTypeSupported = (mimeType) => {
  174.       // Parse the basic MIME type from its parameters.
  175.       const pieces = mimeType.split(/ *; */);
  176.       pieces.shift();  // Remove basic MIME type from pieces.
  178.       const hasCodecs = pieces.some((piece) => piece.startsWith('codecs='));
  179.       if (!hasCodecs) {
  180.         // Though the original reason for this special case was not documented,
  181.         // it is presumed to be because the platform won't accept a MIME type
  182.         // without codecs in canDisplayType.  It is valid, however, in
  183.         // isTypeSupported.
  184.         return originalIsTypeSupported(mimeType);
  185.       }
  187.       // Only canDisplayType can check extended MIME type parameters on this
  188.       // platform (such as frame rate, resolution, etc).
  189.       // In previous versions of this polyfill, the MIME type parameters were
  190.       // manipulated, filtered, or extended.  This is no longer true, so we pass
  191.       // the full MIME type to the platform as we received it.
  192.       return cast.__platform__.canDisplayType(mimeType);
  193.     };
  194.   }
  196.   /**
  197.    * Patch isTypeSupported() to translate vp09 codec strings into vp9, to allow
  198.    * such content to play on older smart TVs.
  199.    *
  200.    * @private
  201.    */
  202.   static patchVp09_() {
  203.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  205.     if (shaka.util.Platform.isWebOS()) {
  206.       // Don't do this on LG webOS as otherwise it is unable
  207.       // to play vp09 at all.
  208.       return;
  209.     }
  211.     MediaSource.isTypeSupported = (mimeType) => {
  212.       // Split the MIME type into its various parameters.
  213.       const pieces = mimeType.split(/ *; */);
  215.       const codecsIndex =
  216.           pieces.findIndex((piece) => piece.startsWith('codecs='));
  217.       if (codecsIndex < 0) {
  218.         // No codec? Call the original without modifying the MIME type.
  219.         return originalIsTypeSupported(mimeType);
  220.       }
  222.       const codecsParam = pieces[codecsIndex];
  223.       const codecs = codecsParam
  224.           .replace('codecs=', '').replace(/"/g, '').split(/\s*,\s*/);
  226.       const vp09Index = codecs.findIndex(
  227.           (codecName) => codecName.startsWith('vp09'));
  228.       if (vp09Index >= 0) {
  229.         // vp09? Replace it with vp9.
  230.         codecs[vp09Index] = 'vp9';
  231.         pieces[codecsIndex] = 'codecs="' + codecs.join(',') + '"';
  232.         mimeType = pieces.join('; ');
  233.       }
  235.       return originalIsTypeSupported(mimeType);
  236.     };
  237.   }
  238. };
  241. shaka.polyfill.register(shaka.polyfill.MediaSource.install);