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 {
  57.         shaka.log.info('Patching Safari 13 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.isTizen2() ||
  65.         shaka.util.Platform.isTizen3() ||
  66.         shaka.util.Platform.isTizen4()) {
  67.       shaka.log.info('Rejecting Opus.');
  68.       // Tizen's implementation of MSE does not work well with opus. To prevent
  69.       // the player from trying to play opus on Tizen, we will override media
  70.       // source to always reject opus content.
  71.       shaka.polyfill.MediaSource.rejectCodec_('opus');
  72.     } else {
  73.       shaka.log.info('Using native MSE as-is.');
  74.     }
  76.     if (window.MediaSource &&
  77.         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
  78.         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
  79.       shaka.log.info('Patching vp09 support queries.');
  80.       // Only the old, deprecated style of VP9 codec strings is supported.
  81.       // This occurs on older smart TVs.
  82.       // Patch isTypeSupported to translate the new strings into the old one.
  83.       shaka.polyfill.MediaSource.patchVp09_();
  84.     }
  85.   }
  87.   /**
  88.    * Stub out abort().  On some buggy MSE implementations, calling abort()
  89.    * causes various problems.
  90.    *
  91.    * @private
  92.    */
  93.   static stubAbort_() {
  94.     /* eslint-disable no-restricted-syntax */
  95.     const addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  96.     MediaSource.prototype.addSourceBuffer = function(...varArgs) {
  97.       const sourceBuffer = addSourceBuffer.apply(this, varArgs);
  98.       sourceBuffer.abort = function() {}; // Stub out for buggy implementations.
  99.       return sourceBuffer;
  100.     };
  101.     /* eslint-enable no-restricted-syntax */
  102.   }
  104.   /**
  105.    * Patch remove().  On Safari 11, if you call remove() to remove the content
  106.    * up to a keyframe, Safari will also remove the keyframe and all of the data
  107.    * up to the next one. For example, if the keyframes are at 0s, 5s, and 10s,
  108.    * and you tried to remove 0s-5s, it would instead remove 0s-10s.
  109.    *
  110.    * Offsetting the end of the range seems to be a usable workaround.
  111.    *
  112.    * @private
  113.    */
  114.   static patchRemovalRange_() {
  115.     // eslint-disable-next-line no-restricted-syntax
  116.     const originalRemove = SourceBuffer.prototype.remove;
  118.     // eslint-disable-next-line no-restricted-syntax
  119.     SourceBuffer.prototype.remove = function(startTime, endTime) {
  120.       // eslint-disable-next-line no-restricted-syntax
  121.       return originalRemove.call(this, startTime, endTime - 0.001);
  122.     };
  123.   }
  125.   /**
  126.    * Patch |MediaSource.isTypeSupported| to always reject |codec|. This is used
  127.    * when we know that we are on a platform that does not work well with a given
  128.    * codec.
  129.    *
  130.    * @param {string} codec
  131.    * @private
  132.    */
  133.   static rejectCodec_(codec) {
  134.     const isTypeSupported = MediaSource.isTypeSupported;
  136.     MediaSource.isTypeSupported = (mimeType) => {
  137.       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  138.       return actualCodec != codec && isTypeSupported(mimeType);
  139.     };
  140.   }
  142.   /**
  143.    * Patch isTypeSupported() to chain to a private API on the Chromecast which
  144.    * can query for support of detailed content parameters.
  145.    *
  146.    * @private
  147.    */
  148.   static patchCastIsTypeSupported_() {
  149.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  151.     MediaSource.isTypeSupported = (mimeType) => {
  152.       // Parse the basic MIME type from its parameters.
  153.       const pieces = mimeType.split(/ *; */);
  154.       pieces.shift();  // Remove basic MIME type from pieces.
  156.       const hasCodecs = pieces.some((piece) => piece.startsWith('codecs='));
  157.       if (!hasCodecs) {
  158.         // Though the original reason for this special case was not documented,
  159.         // it is presumed to be because the platform won't accept a MIME type
  160.         // without codecs in canDisplayType.  It is valid, however, in
  161.         // isTypeSupported.
  162.         return originalIsTypeSupported(mimeType);
  163.       }
  165.       // Only canDisplayType can check extended MIME type parameters on this
  166.       // platform (such as frame rate, resolution, etc).
  167.       // In previous versions of this polyfill, the MIME type parameters were
  168.       // manipulated, filtered, or extended.  This is no longer true, so we pass
  169.       // the full MIME type to the platform as we received it.
  170.       return cast.__platform__.canDisplayType(mimeType);
  171.     };
  172.   }
  174.   /**
  175.    * Patch isTypeSupported() to translate vp09 codec strings into vp9, to allow
  176.    * such content to play on older smart TVs.
  177.    *
  178.    * @private
  179.    */
  180.   static patchVp09_() {
  181.     const originalIsTypeSupported = MediaSource.isTypeSupported;
  183.     if (shaka.util.Platform.isWebOS()) {
  184.       // Don't do this on LG webOS as otherwise it is unable
  185.       // to play vp09 at all.
  186.       return;
  187.     }
  189.     MediaSource.isTypeSupported = (mimeType) => {
  190.       // Split the MIME type into its various parameters.
  191.       const pieces = mimeType.split(/ *; */);
  193.       const codecsIndex =
  194.           pieces.findIndex((piece) => piece.startsWith('codecs='));
  195.       if (codecsIndex < 0) {
  196.         // No codec? Call the original without modifying the MIME type.
  197.         return originalIsTypeSupported(mimeType);
  198.       }
  200.       const codecsParam = pieces[codecsIndex];
  201.       const codecs = codecsParam
  202.           .replace('codecs=', '').replace(/"/g, '').split(/\s*,\s*/);
  204.       const vp09Index = codecs.findIndex(
  205.           (codecName) => codecName.startsWith('vp09'));
  206.       if (vp09Index >= 0) {
  207.         // vp09? Replace it with vp9.
  208.         codecs[vp09Index] = 'vp9';
  209.         pieces[codecsIndex] = 'codecs="' + codecs.join(',') + '"';
  210.         mimeType = pieces.join('; ');
  211.       }
  213.       return originalIsTypeSupported(mimeType);
  214.     };
  215.   }
  216. };
  219. shaka.polyfill.register(shaka.polyfill.MediaSource.install);