Source: lib/polyfill/mediasource.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.polyfill.MediaSource');
  20. goog.require('shaka.log');
  21. goog.require('shaka.polyfill.register');
  22. goog.require('shaka.util.MimeUtils');
  23. goog.require('shaka.util.Platform');
  25. /**
  26.  * @namespace shaka.polyfill.MediaSource
  27.  *
  28.  * @summary A polyfill to patch MSE bugs.
  29.  */
  32. /**
  33.  * Install the polyfill if needed.
  34.  */
  35. shaka.polyfill.MediaSource.install = function() {
  36.   shaka.log.debug('MediaSource.install');
  38.   // MediaSource bugs are difficult to detect without checking for the affected
  39.   // platform.  SourceBuffer is not always exposed on window, for example, and
  40.   // instances are only accessible after setting up MediaSource on a video
  41.   // element.  Because of this, we use UA detection and other platform detection
  42.   // tricks to decide which patches to install.
  44.   if (!window.MediaSource) {
  45.     shaka.log.info('No MSE implementation available.');
  46.   } else if (window.cast && cast.__platform__ &&
  47.              cast.__platform__.canDisplayType) {
  48.     shaka.log.info('Patching Chromecast MSE bugs.');
  49.     // Chromecast cannot make accurate determinations via isTypeSupported.
  50.     shaka.polyfill.MediaSource.patchCastIsTypeSupported_();
  51.   } else if (navigator.vendor && navigator.vendor.indexOf('Apple') >= 0) {
  52.     let version = navigator.appVersion;
  54.     // TS content is broken on Safari in general.
  55.     // See https://github.com/google/shaka-player/issues/743
  56.     // and https://bugs.webkit.org/show_bug.cgi?id=165342
  57.     shaka.polyfill.MediaSource.rejectTsContent_();
  59.     if (version.indexOf('Version/8') >= 0) {
  60.       // Safari 8 does not implement appendWindowEnd.  If we ignore the
  61.       // incomplete MSE implementation, some content (especially multi-period)
  62.       // will fail to play correctly.  The best we can do is blacklist Safari 8.
  63.       shaka.log.info('Blacklisting Safari 8 MSE.');
  64.       shaka.polyfill.MediaSource.blacklist_();
  65.     } else if (version.indexOf('Version/9') >= 0) {
  66.       shaka.log.info('Patching Safari 9 MSE bugs.');
  67.       // Safari 9 does not correctly implement abort() on SourceBuffer.
  68.       // Calling abort() causes a decoder failure, rather than resetting the
  69.       // decode timestamp as called for by the spec.
  70.       // Bug filed: http://goo.gl/UZ2rPp
  71.       shaka.polyfill.MediaSource.stubAbort_();
  72.     } else if (version.indexOf('Version/10') >= 0) {
  73.       shaka.log.info('Patching Safari 10 MSE bugs.');
  74.       // Safari 10 does not correctly implement abort() on SourceBuffer.
  75.       // Calling abort() before appending a segment causes that segment to be
  76.       // incomplete in buffer.
  77.       // Bug filed: https://goo.gl/rC3CLj
  78.       shaka.polyfill.MediaSource.stubAbort_();
  79.       // Safari 10 fires spurious 'updateend' events after endOfStream().
  80.       // Bug filed: https://goo.gl/qCeTZr
  81.       shaka.polyfill.MediaSource.patchEndOfStreamEvents_();
  82.     } else if (version.includes('Version/11') ||
  83.                version.includes('Version/12')) {
  84.       shaka.log.info('Patching Safari 11/12 MSE bugs.');
  85.       // Safari 11 does not correctly implement abort() on SourceBuffer.
  86.       // Calling abort() before appending a segment causes that segment to be
  87.       // incomplete in the buffer.
  88.       // Bug filed: https://goo.gl/rC3CLj
  89.       shaka.polyfill.MediaSource.stubAbort_();
  90.       // If you remove up to a keyframe, Safari 11 incorrectly will also remove
  91.       // that keyframe and the content up to the next.
  92.       // Offsetting the end of the removal range seems to help.
  93.       // Bug filed: https://goo.gl/h2yDPN
  94.       shaka.polyfill.MediaSource.patchRemovalRange_();
  95.     }
  96.   } else if (shaka.util.Platform.isTizen()) {
  97.     // Tizen's implementation of MSE does not work well with opus. To prevent
  98.     // the player from trying to play opus on Tizen, we will override media
  99.     // source to always reject opus content.
  101.     shaka.polyfill.MediaSource.rejectCodec_('opus');
  102.   } else {
  103.     shaka.log.info('Using native MSE as-is.');
  104.   }
  105. };
  108. /**
  109.  * Blacklist the current browser by making MediaSourceEngine.isBrowserSupported
  110.  * fail later.
  111.  *
  112.  * @private
  113.  */
  114. shaka.polyfill.MediaSource.blacklist_ = function() {
  115.   window['MediaSource'] = null;
  116. };
  119. /**
  120.  * Stub out abort().  On some buggy MSE implementations, calling abort() causes
  121.  * various problems.
  122.  *
  123.  * @private
  124.  */
  125. shaka.polyfill.MediaSource.stubAbort_ = function() {
  126.   const addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  127.   MediaSource.prototype.addSourceBuffer = function() {
  128.     let sourceBuffer = addSourceBuffer.apply(this, arguments);
  129.     sourceBuffer.abort = function() {};  // Stub out for buggy implementations.
  130.     return sourceBuffer;
  131.   };
  132. };
  135. /**
  136.  * Patch remove().  On Safari 11, if you call remove() to remove the content up
  137.  * to a keyframe, Safari will also remove the keyframe and all of the data up to
  138.  * the next one. For example, if the keyframes are at 0s, 5s, and 10s, and you
  139.  * tried to remove 0s-5s, it would instead remove 0s-10s.
  140.  *
  141.  * Offsetting the end of the range seems to be a usable workaround.
  142.  *
  143.  * @private
  144.  */
  145. shaka.polyfill.MediaSource.patchRemovalRange_ = function() {
  146.   const originalRemove = SourceBuffer.prototype.remove;
  148.   SourceBuffer.prototype.remove = function(startTime, endTime) {
  149.     return originalRemove.call(this, startTime, endTime - 0.001);
  150.   };
  151. };
  154. /**
  155.  * Patch endOfStream() to get rid of 'updateend' events that should not fire.
  156.  * These extra events confuse MediaSourceEngine, which relies on correct events
  157.  * to manage SourceBuffer state.
  158.  *
  159.  * @private
  160.  */
  161. shaka.polyfill.MediaSource.patchEndOfStreamEvents_ = function() {
  162.   const endOfStream = MediaSource.prototype.endOfStream;
  163.   MediaSource.prototype.endOfStream = function() {
  164.     // This bug manifests only when endOfStream() results in the truncation
  165.     // of the MediaSource's duration.  So first we must calculate what the
  166.     // new duration will be.
  167.     let newDuration = 0;
  168.     for (let i = 0; i < this.sourceBuffers.length; ++i) {
  169.       let buffer = this.sourceBuffers[i];
  170.       let bufferEnd = buffer.buffered.end(buffer.buffered.length - 1);
  171.       newDuration = Math.max(newDuration, bufferEnd);
  172.     }
  174.     // If the duration is going to be reduced, suppress the next 'updateend'
  175.     // event on each SourceBuffer.
  176.     if (!isNaN(this.duration) &&
  177.         newDuration < this.duration) {
  178.       this.ignoreUpdateEnd_ = true;
  179.       for (let i = 0; i < this.sourceBuffers.length; ++i) {
  180.         let buffer = this.sourceBuffers[i];
  181.         buffer.eventSuppressed_ = false;
  182.       }
  183.     }
  185.     return endOfStream.apply(this, arguments);
  186.   };
  188.   let cleanUpHandlerInstalled = false;
  189.   let addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  190.   MediaSource.prototype.addSourceBuffer = function() {
  191.     // After adding a new source buffer, add an event listener to allow us to
  192.     // suppress events.
  193.     let sourceBuffer = addSourceBuffer.apply(this, arguments);
  194.     sourceBuffer['mediaSource_'] = this;
  195.     sourceBuffer.addEventListener('updateend',
  196.         shaka.polyfill.MediaSource.ignoreUpdateEnd_, false);
  198.     if (!cleanUpHandlerInstalled) {
  199.       // If we haven't already, install an event listener to allow us to clean
  200.       // up listeners when MediaSource is torn down.
  201.       this.addEventListener('sourceclose',
  202.           shaka.polyfill.MediaSource.cleanUpListeners_, false);
  203.       cleanUpHandlerInstalled = true;
  204.     }
  205.     return sourceBuffer;
  206.   };
  207. };
  210. /**
  211.  * An event listener for 'updateend' which selectively suppresses the events.
  212.  *
  213.  * @see shaka.polyfill.MediaSource.patchEndOfStreamEvents_
  214.  *
  215.  * @param {Event} event
  216.  * @private
  217.  */
  218. shaka.polyfill.MediaSource.ignoreUpdateEnd_ = function(event) {
  219.   let sourceBuffer = event.target;
  220.   let mediaSource = sourceBuffer['mediaSource_'];
  222.   if (mediaSource.ignoreUpdateEnd_) {
  223.     event.preventDefault();
  224.     event.stopPropagation();
  225.     event.stopImmediatePropagation();
  226.     sourceBuffer.eventSuppressed_ = true;
  228.     for (let i = 0; i < mediaSource.sourceBuffers.length; ++i) {
  229.       let buffer = mediaSource.sourceBuffers[i];
  230.       if (buffer.eventSuppressed_ == false) {
  231.         // More events need to be suppressed.
  232.         return;
  233.       }
  234.     }
  236.     // All events have been suppressed, all buffers are out of 'updating'
  237.     // mode.  Stop suppressing events.
  238.     mediaSource.ignoreUpdateEnd_ = false;
  239.   }
  240. };
  243. /**
  244.  * An event listener for 'sourceclose' which cleans up listeners for 'updateend'
  245.  * to avoid memory leaks.
  246.  *
  247.  * @see shaka.polyfill.MediaSource.patchEndOfStreamEvents_
  248.  * @see shaka.polyfill.MediaSource.ignoreUpdateEnd_
  249.  *
  250.  * @param {Event} event
  251.  * @private
  252.  */
  253. shaka.polyfill.MediaSource.cleanUpListeners_ = function(event) {
  254.   let mediaSource = /** @type {!MediaSource} */ (event.target);
  255.   for (let i = 0; i < mediaSource.sourceBuffers.length; ++i) {
  256.     let buffer = mediaSource.sourceBuffers[i];
  257.     buffer.removeEventListener('updateend',
  258.         shaka.polyfill.MediaSource.ignoreUpdateEnd_, false);
  259.   }
  260.   mediaSource.removeEventListener('sourceclose',
  261.       shaka.polyfill.MediaSource.cleanUpListeners_, false);
  262. };
  265. /**
  266.  * Patch isTypeSupported() to reject TS content.  Used to avoid TS-related MSE
  267.  * bugs on Safari.
  268.  *
  269.  * @private
  270.  */
  271. shaka.polyfill.MediaSource.rejectTsContent_ = function() {
  272.   const originalIsTypeSupported = MediaSource.isTypeSupported;
  274.   MediaSource.isTypeSupported = function(mimeType) {
  275.     // Parse the basic MIME type from its parameters.
  276.     let pieces = mimeType.split(/ *; */);
  277.     let basicMimeType = pieces[0];
  278.     let container = basicMimeType.split('/')[1];
  280.     if (container == 'mp2t') {
  281.       return false;
  282.     }
  284.     return originalIsTypeSupported(mimeType);
  285.   };
  286. };
  289. /**
  290.  * Patch |MediaSource.isTypeSupported| to always reject |codec|. This is used
  291.  * when we know that we are on a platform that does not work well with a given
  292.  * codec.
  293.  *
  294.  * @param {string} codec
  295.  * @private
  296.  */
  297. shaka.polyfill.MediaSource.rejectCodec_ = function(codec) {
  298.   const isTypeSupported = MediaSource.isTypeSupported;
  300.   MediaSource.isTypeSupported = (mimeType) => {
  301.     const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
  302.     return actualCodec != codec && isTypeSupported(mimeType);
  303.   };
  304. };
  307. /**
  308.  * Patch isTypeSupported() to parse for HDR-related clues and chain to a private
  309.  * API on the Chromecast which can query for support.
  310.  *
  311.  * @private
  312.  */
  313. shaka.polyfill.MediaSource.patchCastIsTypeSupported_ = function() {
  314.   const originalIsTypeSupported = MediaSource.isTypeSupported;
  316.   // Docs from Dolby detailing profile names: https://goo.gl/LVVXrS
  317.   let dolbyVisionRegex = /^dv(?:he|av)\./;
  319.   MediaSource.isTypeSupported = function(mimeType) {
  320.     // Parse the basic MIME type from its parameters.
  321.     let pieces = mimeType.split(/ *; */);
  322.     let basicMimeType = pieces[0];
  324.     // Parse the parameters into key-value pairs.
  325.     /** @type {Object.<string, string>} */
  326.     let parameters = {};
  327.     for (let i = 1; i < pieces.length; ++i) {
  328.       let kv = pieces[i].split('=');
  329.       let k = kv[0];
  330.       let v = kv[1].replace(/"(.*)"/, '$1');
  331.       parameters[k] = v;
  332.     }
  334.     let codecs = parameters['codecs'];
  335.     if (!codecs) {
  336.       return originalIsTypeSupported(mimeType);
  337.     }
  339.     let isHDR = false;
  340.     let isDolbyVision = false;
  342.     let codecList = codecs.split(',').filter(function(codec) {
  343.       // Remove Dolby Vision codec strings.  These are not understood on
  344.       // Chromecast, even though the content can still be played.
  345.       if (dolbyVisionRegex.test(codec)) {
  346.         isDolbyVision = true;
  347.         // Return false to remove this string from the list.
  348.         return false;
  349.       }
  351.       // We take this string as a signal for HDR, but don't remove it.
  352.       if (/^(hev|hvc)1\.2/.test(codec)) {
  353.         isHDR = true;
  354.       }
  356.       // Keep all other strings in the list.
  357.       return true;
  358.     });
  360.     // If the content uses Dolby Vision, we take this as a sign that the content
  361.     // is not HDR after all.
  362.     if (isDolbyVision) isHDR = false;
  364.     // Reconstruct the "codecs" parameter from the results of the filter.
  365.     parameters['codecs'] = codecList.join(',');
  367.     // If the content is HDR, we add this additional parameter so that the Cast
  368.     // platform will check for HDR support.
  369.     if (isHDR) {
  370.       parameters['eotf'] = 'smpte2084';
  371.     }
  373.     // Reconstruct the MIME type, possibly with additional parameters.
  374.     let extendedMimeType = basicMimeType;
  375.     for (let k in parameters) {
  376.       let v = parameters[k];
  377.       extendedMimeType += '; ' + k + '="' + v + '"';
  378.     }
  379.     return cast.__platform__.canDisplayType(extendedMimeType);
  380.   };
  381. };
  384. shaka.polyfill.register(shaka.polyfill.MediaSource.install);