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');
  24. /**
  25.  * @namespace shaka.polyfill.MediaSource
  26.  *
  27.  * @summary A polyfill to patch MSE bugs.
  28.  */
  31. /**
  32.  * Install the polyfill if needed.
  33.  */
  34. shaka.polyfill.MediaSource.install = function() {
  35.   shaka.log.debug('MediaSource.install');
  37.   // MediaSource bugs are difficult to detect without checking for the affected
  38.   // platform.  SourceBuffer is not always exposed on window, for example, and
  39.   // instances are only accessible after setting up MediaSource on a video
  40.   // element.  Because of this, we use UA detection and other platform detection
  41.   // tricks to decide which patches to install.
  43.   if (!window.MediaSource) {
  44.     shaka.log.info('No MSE implementation available.');
  45.   } else if (window.cast && cast.__platform__ &&
  46.              cast.__platform__.canDisplayType) {
  47.     shaka.log.info('Patching Chromecast MSE bugs.');
  48.     // Chromecast cannot make accurate determinations via isTypeSupported.
  49.     shaka.polyfill.MediaSource.patchCastIsTypeSupported_();
  50.   } else if (navigator.vendor && navigator.vendor.indexOf('Apple') >= 0) {
  51.     var version = navigator.appVersion;
  53.     if (version.indexOf('Version/8') >= 0) {
  54.       // Safari 8 does not implement appendWindowEnd.  If we ignore the
  55.       // incomplete MSE implementation, some content (especially multi-period)
  56.       // will fail to play correctly.  The best we can do is blacklist Safari 8.
  57.       shaka.log.info('Blacklisting Safari 8 MSE.');
  58.       shaka.polyfill.MediaSource.blacklist_();
  59.     } else if (version.indexOf('Version/9') >= 0) {
  60.       shaka.log.info('Patching Safari 9 MSE bugs.');
  61.       // Safari 9 does not correctly implement abort() on SourceBuffer.
  62.       // Calling abort() causes a decoder failure, rather than resetting the
  63.       // decode timestamp as called for by the spec.
  64.       // Bug filed: http://goo.gl/UZ2rPp
  65.       shaka.polyfill.MediaSource.stubAbort_();
  66.     } else if (version.indexOf('Version/10') >= 0) {
  67.       shaka.log.info('Patching Safari 10 MSE bugs.');
  68.       // Safari 10 does not correctly implement abort() on SourceBuffer.
  69.       // Calling abort() before appending a segment causes that segment to be
  70.       // incomplete in buffer.
  71.       // Bug filed: https://goo.gl/rC3CLj
  72.       shaka.polyfill.MediaSource.stubAbort_();
  73.       // Safari 10 fires spurious 'updateend' events after endOfStream().
  74.       // Bug filed: https://goo.gl/qCeTZr
  75.       shaka.polyfill.MediaSource.patchEndOfStreamEvents_();
  76.     }
  77.   } else {
  78.     shaka.log.info('Using native MSE as-is.');
  79.   }
  80. };
  83. /**
  84.  * Blacklist the current browser by making MediaSourceEngine.isBrowserSupported
  85.  * fail later.
  86.  *
  87.  * @private
  88.  */
  89. shaka.polyfill.MediaSource.blacklist_ = function() {
  90.   window['MediaSource'] = null;
  91. };
  94. /**
  95.  * Stub out abort().  On some buggy MSE implementations, calling abort() causes
  96.  * various problems.
  97.  *
  98.  * @private
  99.  */
  100. shaka.polyfill.MediaSource.stubAbort_ = function() {
  101.   var addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  102.   MediaSource.prototype.addSourceBuffer = function() {
  103.     var sourceBuffer = addSourceBuffer.apply(this, arguments);
  104.     sourceBuffer.abort = function() {};  // Stub out for buggy implementations.
  105.     return sourceBuffer;
  106.   };
  107. };
  110. /**
  111.  * Patch endOfStream() to get rid of 'updateend' events that should not fire.
  112.  * These extra events confuse MediaSourceEngine, which relies on correct events
  113.  * to manage SourceBuffer state.
  114.  *
  115.  * @private
  116.  */
  117. shaka.polyfill.MediaSource.patchEndOfStreamEvents_ = function() {
  118.   var endOfStream = MediaSource.prototype.endOfStream;
  119.   MediaSource.prototype.endOfStream = function() {
  120.     // This bug manifests only when endOfStream() results in the truncation
  121.     // of the MediaSource's duration.  So first we must calculate what the
  122.     // new duration will be.
  123.     var newDuration = 0;
  124.     for (var i = 0; i < this.sourceBuffers.length; ++i) {
  125.       var buffer = this.sourceBuffers[i];
  126.       var bufferEnd = buffer.buffered.end(buffer.buffered.length - 1);
  127.       newDuration = Math.max(newDuration, bufferEnd);
  128.     }
  130.     // If the duration is going to be reduced, suppress the next 'updateend'
  131.     // event on each SourceBuffer.
  132.     if (!isNaN(this.duration) &&
  133.         newDuration < this.duration) {
  134.       this.ignoreUpdateEnd_ = true;
  135.       for (var i = 0; i < this.sourceBuffers.length; ++i) {
  136.         var buffer = this.sourceBuffers[i];
  137.         buffer.eventSuppressed_ = false;
  138.       }
  139.     }
  141.     return endOfStream.apply(this, arguments);
  142.   };
  144.   var cleanUpHandlerInstalled = false;
  145.   var addSourceBuffer = MediaSource.prototype.addSourceBuffer;
  146.   MediaSource.prototype.addSourceBuffer = function() {
  147.     // After adding a new source buffer, add an event listener to allow us to
  148.     // suppress events.
  149.     var sourceBuffer = addSourceBuffer.apply(this, arguments);
  150.     sourceBuffer['mediaSource_'] = this;
  151.     sourceBuffer.addEventListener('updateend',
  152.         shaka.polyfill.MediaSource.ignoreUpdateEnd_, false);
  154.     if (!cleanUpHandlerInstalled) {
  155.       // If we haven't already, install an event listener to allow us to clean
  156.       // up listeners when MediaSource is torn down.
  157.       this.addEventListener('sourceclose',
  158.           shaka.polyfill.MediaSource.cleanUpListeners_, false);
  159.       cleanUpHandlerInstalled = true;
  160.     }
  161.     return sourceBuffer;
  162.   };
  163. };
  166. /**
  167.  * An event listener for 'updateend' which selectively suppresses the events.
  168.  *
  169.  * @see shaka.polyfill.MediaSource.patchEndOfStreamEvents_
  170.  *
  171.  * @param {Event} event
  172.  * @private
  173.  */
  174. shaka.polyfill.MediaSource.ignoreUpdateEnd_ = function(event) {
  175.   var sourceBuffer = event.target;
  176.   var mediaSource = sourceBuffer['mediaSource_'];
  178.   if (mediaSource.ignoreUpdateEnd_) {
  179.     event.preventDefault();
  180.     event.stopPropagation();
  181.     event.stopImmediatePropagation();
  182.     sourceBuffer.eventSuppressed_ = true;
  184.     for (var i = 0; i < mediaSource.sourceBuffers.length; ++i) {
  185.       var buffer = mediaSource.sourceBuffers[i];
  186.       if (buffer.eventSuppressed_ == false) {
  187.         // More events need to be suppressed.
  188.         return;
  189.       }
  190.     }
  192.     // All events have been suppressed, all buffers are out of 'updating'
  193.     // mode.  Stop suppressing events.
  194.     mediaSource.ignoreUpdateEnd_ = false;
  195.   }
  196. };
  199. /**
  200.  * An event listener for 'sourceclose' which cleans up listeners for 'updateend'
  201.  * to avoid memory leaks.
  202.  *
  203.  * @see shaka.polyfill.MediaSource.patchEndOfStreamEvents_
  204.  * @see shaka.polyfill.MediaSource.ignoreUpdateEnd_
  205.  *
  206.  * @param {Event} event
  207.  * @private
  208.  */
  209. shaka.polyfill.MediaSource.cleanUpListeners_ = function(event) {
  210.   var mediaSource = /** @type {!MediaSource} */ (event.target);
  211.   for (var i = 0; i < mediaSource.sourceBuffers.length; ++i) {
  212.     var buffer = mediaSource.sourceBuffers[i];
  213.     buffer.removeEventListener('updateend',
  214.         shaka.polyfill.MediaSource.ignoreUpdateEnd_, false);
  215.   }
  216.   mediaSource.removeEventListener('sourceclose',
  217.       shaka.polyfill.MediaSource.cleanUpListeners_, false);
  218. };
  221. /**
  222.  * Patch isTypeSupported() to parse for HDR-related clues and chain to a private
  223.  * API on the Chromecast which can query for support.
  224.  *
  225.  * @private
  226.  */
  227. shaka.polyfill.MediaSource.patchCastIsTypeSupported_ = function() {
  228.   var originalIsTypeSupported = MediaSource.isTypeSupported;
  230.   // Docs from Dolby detailing profile names: https://goo.gl/LVVXrS
  231.   var dolbyVisionRegex = /^dv(?:he|av)\./;
  233.   MediaSource.isTypeSupported = function(mimeType) {
  234.     // Parse the basic MIME type from its parameters.
  235.     var pieces = mimeType.split(/ *; */);
  236.     var basicMimeType = pieces[0];
  238.     // Parse the parameters into key-value pairs.
  239.     /** @type {Object.<string, string>} */
  240.     var parameters = {};
  241.     for (var i = 1; i < pieces.length; ++i) {
  242.       var kv = pieces[i].split('=');
  243.       var k = kv[0];
  244.       var v = kv[1].replace(/"(.*)"/, '$1');
  245.       parameters[k] = v;
  246.     }
  248.     var codecs = parameters['codecs'];
  249.     if (!codecs) {
  250.       return originalIsTypeSupported(mimeType);
  251.     }
  253.     var isHDR = false;
  254.     var isDolbyVision = false;
  256.     var codecList = codecs.split(',').filter(function(codec) {
  257.       // Remove Dolby Vision codec strings.  These are not understood on
  258.       // Chromecast, even though the content can still be played.
  259.       if (dolbyVisionRegex.test(codec)) {
  260.         isDolbyVision = true;
  261.         // Return false to remove this string from the list.
  262.         return false;
  263.       }
  265.       // We take this string as a signal for HDR, but don't remove it.
  266.       if (/^(hev|hvc)1\.2/.test(codec)) {
  267.         isHDR = true;
  268.       }
  270.       // Keep all other strings in the list.
  271.       return true;
  272.     });
  274.     // If the content uses Dolby Vision, we take this as a sign that the content
  275.     // is not HDR after all.
  276.     if (isDolbyVision) isHDR = false;
  278.     // Reconstruct the "codecs" parameter from the results of the filter.
  279.     parameters['codecs'] = codecList.join(',');
  281.     // If the content is HDR, we add this additional parameter so that the Cast
  282.     // platform will check for HDR support.
  283.     if (isHDR) {
  284.       parameters['eotf'] = 'smpte2084';
  285.     }
  287.     // Reconstruct the MIME type, possibly with additional parameters.
  288.     var extendedMimeType = basicMimeType;
  289.     for (var k in parameters) {
  290.       var v = parameters[k];
  291.       extendedMimeType += '; ' + k + '="' + v + '"';
  292.     }
  293.     return cast.__platform__.canDisplayType(extendedMimeType);
  294.   };
  295. };
  298. shaka.polyfill.register(shaka.polyfill.MediaSource.install);