Source: lib/media/media_source_engine.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.media.MediaSourceEngine');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.TimeRangesUtils');
  23. goog.require('shaka.media.Transmuxer');
  24. goog.require('shaka.text.TextEngine');
  25. goog.require('shaka.util.Error');
  26. goog.require('shaka.util.EventManager');
  27. goog.require('shaka.util.Functional');
  28. goog.require('shaka.util.IDestroyable');
  29. goog.require('shaka.util.ManifestParserUtils');
  30. goog.require('shaka.util.MimeUtils');
  31. goog.require('shaka.util.PublicPromise');
  35. /**
  36.  * MediaSourceEngine wraps all operations on MediaSource and SourceBuffers.
  37.  * All asynchronous operations return a Promise, and all operations are
  38.  * internally synchronized and serialized as needed.  Operations that can
  39.  * be done in parallel will be done in parallel.
  40.  *
  41.  * @param {HTMLMediaElement} video The video element, whose source is tied to
  42.  *   MediaSource during the lifetime of the MediaSourceEngine.
  43.  *
  44.  * @struct
  45.  * @constructor
  46.  * @implements {shaka.util.IDestroyable}
  47.  */
  48. shaka.media.MediaSourceEngine = function(video) {
  49.   /** @private {HTMLMediaElement} */
  50.   this.video_ = video;
  52.   /** @private {shakaExtern.TextDisplayer} */
  53.   this.textDisplayer_ = null;
  55.   /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  56.                          SourceBuffer>} */
  57.   this.sourceBuffers_ = {};
  59.   /** @private {shaka.text.TextEngine} */
  60.   this.textEngine_ = null;
  62.   /**
  63.    * @private {!Object.<string,
  64.    *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
  65.    */
  66.   this.queues_ = {};
  68.   /** @private {shaka.util.EventManager} */
  69.   this.eventManager_ = new shaka.util.EventManager();
  71.   /** @private {boolean} */
  72.   this.destroyed_ = false;
  74.   /** @private {!Object.<string, !shaka.media.Transmuxer>} */
  75.   this.transmuxers_ = {};
  77.   /** @private {boolean} */
  78.   this.useEmbeddedText_ = false;
  80.   /** @private {!shaka.util.PublicPromise} */
  81.   this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  83.   /** @private {MediaSource} */
  84.   this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  85. };
  88. /**
  89.  * Create a MediaSource object, attach it to the video element, and return it.
  90.  * Resolves the given promise when the MediaSource is ready.
  91.  *
  92.  * Replaced by unit tests.
  93.  *
  94.  * @param {!shaka.util.PublicPromise} p
  95.  * @return {!MediaSource}
  96.  */
  97. shaka.media.MediaSourceEngine.prototype.createMediaSource = function(p) {
  98.   let mediaSource = new MediaSource();
  100.   // Set up MediaSource on the video element.
  101.   this.eventManager_.listenOnce(mediaSource, 'sourceopen', p.resolve);
  102.   this.video_.src = window.URL.createObjectURL(mediaSource);
  104.   return mediaSource;
  105. };
  108. /**
  109.  * @typedef {{
  110.  *   start: function(),
  111.  *   p: !shaka.util.PublicPromise
  112.  * }}
  113.  *
  114.  * @summary An operation in queue.
  115.  * @property {function()} start
  116.  *   The function which starts the operation.
  117.  * @property {!shaka.util.PublicPromise} p
  118.  *   The PublicPromise which is associated with this operation.
  119.  */
  120. shaka.media.MediaSourceEngine.Operation;
  123. /**
  124.  * Checks if a certain type is supported.
  125.  *
  126.  * @param {shakaExtern.Stream} stream
  127.  * @return {boolean}
  128.  */
  129. shaka.media.MediaSourceEngine.isStreamSupported = function(stream) {
  130.   let fullMimeType = shaka.util.MimeUtils.getFullType(
  131.       stream.mimeType, stream.codecs);
  132.   let extendedMimeType = shaka.util.MimeUtils.getExtendedType(stream);
  133.   return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
  134.       MediaSource.isTypeSupported(extendedMimeType) ||
  135.       shaka.media.Transmuxer.isSupported(fullMimeType, stream.type);
  136. };
  139. /**
  140.  * Returns true if the browser has the basic APIs we need.
  141.  *
  142.  * @return {boolean}
  143.  */
  144. shaka.media.MediaSourceEngine.isBrowserSupported = function() {
  145.   return !!window.MediaSource && !!MediaSource.isTypeSupported;
  146. };
  149. /**
  150.  * Returns a map of MediaSource support for well-known types.
  151.  *
  152.  * @return {!Object.<string, boolean>}
  153.  */
  154. shaka.media.MediaSourceEngine.probeSupport = function() {
  155.   goog.asserts.assert(shaka.media.MediaSourceEngine.isBrowserSupported(),
  156.                       'Requires basic support');
  157.   let support = {};
  158.   let testMimeTypes = [
  159.     // MP4 types
  160.     'video/mp4; codecs="avc1.42E01E"',
  161.     'video/mp4; codecs="avc3.42E01E"',
  162.     'video/mp4; codecs="hev1.1.6.L93.90"',
  163.     'video/mp4; codecs="hvc1.1.6.L93.90"',
  164.     'video/mp4; codecs="hev1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  165.     'video/mp4; codecs="hvc1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  166.     'video/mp4; codecs="vp9"',
  167.     'video/mp4; codecs="vp09.00.10.08"',
  168.     'audio/mp4; codecs="mp4a.40.2"',
  169.     'audio/mp4; codecs="ac-3"',
  170.     'audio/mp4; codecs="ec-3"',
  171.     'audio/mp4; codecs="opus"',
  172.     'audio/mp4; codecs="flac"',
  173.     // WebM types
  174.     'video/webm; codecs="vp8"',
  175.     'video/webm; codecs="vp9"',
  176.     'video/webm; codecs="vp09.00.10.08"',
  177.     'audio/webm; codecs="vorbis"',
  178.     'audio/webm; codecs="opus"',
  179.     // MPEG2 TS types (video/ is also used for audio: http://goo.gl/tYHXiS)
  180.     'video/mp2t; codecs="avc1.42E01E"',
  181.     'video/mp2t; codecs="avc3.42E01E"',
  182.     'video/mp2t; codecs="hvc1.1.6.L93.90"',
  183.     'video/mp2t; codecs="mp4a.40.2"',
  184.     'video/mp2t; codecs="ac-3"',
  185.     'video/mp2t; codecs="ec-3"',
  186.     // WebVTT types
  187.     'text/vtt',
  188.     'application/mp4; codecs="wvtt"',
  189.     // TTML types
  190.     'application/ttml+xml',
  191.     'application/mp4; codecs="stpp"'
  192.   ];
  194.   testMimeTypes.forEach(function(type) {
  195.     support[type] = shaka.text.TextEngine.isTypeSupported(type) ||
  196.         MediaSource.isTypeSupported(type) ||
  197.         shaka.media.Transmuxer.isSupported(type);
  198.     let basicType = type.split(';')[0];
  199.     support[basicType] = support[basicType] || support[type];
  200.   });
  202.   return support;
  203. };
  206. /** @override */
  207. shaka.media.MediaSourceEngine.prototype.destroy = function() {
  208.   const Functional = shaka.util.Functional;
  209.   this.destroyed_ = true;
  211.   let cleanup = [];
  213.   for (let contentType in this.queues_) {
  214.     // Make a local copy of the queue and the first item.
  215.     let q = this.queues_[contentType];
  216.     let inProgress = q[0];
  218.     // Drop everything else out of the original queue.
  219.     this.queues_[contentType] = q.slice(0, 1);
  221.     // We will wait for this item to complete/fail.
  222.     if (inProgress) {
  223.       cleanup.push(inProgress.p.catch(Functional.noop));
  224.     }
  226.     // The rest will be rejected silently if possible.
  227.     for (let i = 1; i < q.length; ++i) {
  228.       q[i].p.catch(Functional.noop);
  229.       q[i].p.reject();
  230.     }
  231.   }
  233.   if (this.textEngine_) {
  234.     cleanup.push(this.textEngine_.destroy());
  235.   }
  236.   for (let contentType in this.transmuxers_) {
  237.     cleanup.push(this.transmuxers_[contentType].destroy());
  238.   }
  240.   return Promise.all(cleanup).then(function() {
  241.     let p = this.eventManager_ ? this.eventManager_.destroy() : null;
  243.     if (this.video_) {
  244.       this.video_.removeAttribute('src');
  245.       this.video_.load();
  246.     }
  248.     this.eventManager_ = null;
  249.     this.video_ = null;
  250.     this.mediaSource_ = null;
  251.     this.textEngine_ = null;
  252.     this.textDisplayer_ = null;
  253.     this.sourceBuffers_ = {};
  254.     this.transmuxers_ = {};
  255.     if (goog.DEBUG) {
  256.       for (let contentType in this.queues_) {
  257.         goog.asserts.assert(
  258.             this.queues_[contentType].length == 0,
  259.             contentType + ' queue should be empty after destroy!');
  260.       }
  261.     }
  262.     this.queues_ = {};
  264.     return p;
  265.   }.bind(this));
  266. };
  269. /**
  270.  * @return {!Promise} Resolved when MediaSource is open and attached to the
  271.  *   media element.  This process is actually initiated by the constructor.
  272.  */
  273. shaka.media.MediaSourceEngine.prototype.open = function() {
  274.   return this.mediaSourceOpen_;
  275. };
  278. /**
  279.  * Initialize MediaSourceEngine.
  280.  *
  281.  * Note that it is not valid to call this multiple times, except to add or
  282.  * reinitialize text streams.
  283.  *
  284.  * @param {!Object.<shaka.util.ManifestParserUtils.ContentType,
  285.  *                  shakaExtern.Stream>} streamsByType
  286.  *   A map of content types to streams.  All streams must be supported according
  287.  *   to MediaSourceEngine.isStreamSupported.
  288.  * @param {boolean} forceTransmuxTS
  289.  *   If true, this will transmux TS content even if it is natively supported.
  290.  *
  291.  * @return {!Promise}
  292.  *
  293.  * @throws InvalidAccessError if blank MIME types are given
  294.  * @throws NotSupportedError if unsupported MIME types are given
  295.  * @throws QuotaExceededError if the browser can't support that many buffers
  296.  */
  297. shaka.media.MediaSourceEngine.prototype.init = function(
  298.     streamsByType, forceTransmuxTS) {
  299.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  301.   return this.mediaSourceOpen_.then(() => {
  302.     for (let contentType in streamsByType) {
  303.       let stream = streamsByType[contentType];
  304.       goog.asserts.assert(
  305.           shaka.media.MediaSourceEngine.isStreamSupported(stream),
  306.           'Type negotiation should happen before MediaSourceEngine.init!');
  308.       let mimeType = shaka.util.MimeUtils.getFullType(
  309.           stream.mimeType, stream.codecs);
  310.       if (contentType == ContentType.TEXT) {
  311.         this.reinitText(mimeType);
  312.       } else {
  313.         if ((forceTransmuxTS || !MediaSource.isTypeSupported(mimeType)) &&
  314.             shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
  315.           this.transmuxers_[contentType] = new shaka.media.Transmuxer();
  316.           mimeType =
  317.               shaka.media.Transmuxer.convertTsCodecs(contentType, mimeType);
  318.         }
  319.         let sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
  320.         this.eventManager_.listen(
  321.             sourceBuffer, 'error',
  322.             this.onError_.bind(this, contentType));
  323.         this.eventManager_.listen(
  324.             sourceBuffer, 'updateend',
  325.             this.onUpdateEnd_.bind(this, contentType));
  326.         this.sourceBuffers_[contentType] = sourceBuffer;
  327.         this.queues_[contentType] = [];
  328.       }
  329.     }
  330.   });
  331. };
  334. /**
  335.  * @param {shakaExtern.TextDisplayer} textDisplayer
  336.  */
  337. shaka.media.MediaSourceEngine.prototype.setTextDisplayer =
  338.     function(textDisplayer) {
  339.   this.textDisplayer_ = textDisplayer;
  340. };
  343. /**
  344.  * Reinitialize the TextEngine for a new text type.
  345.  * @param {string} mimeType
  346.  */
  347. shaka.media.MediaSourceEngine.prototype.reinitText = function(mimeType) {
  348.   if (!this.textEngine_) {
  349.     this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
  350.   }
  351.   this.textEngine_.initParser(mimeType);
  352. };
  355. /**
  356.  * @return {boolean} True if the MediaSource is in an "ended" state, or if the
  357.  *   object has been destroyed.
  358.  */
  359. shaka.media.MediaSourceEngine.prototype.ended = function() {
  360.   return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
  361. };
  364. /**
  365.  * Gets the first timestamp in buffer for the given content type.
  366.  *
  367.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  368.  * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  369.  */
  370. shaka.media.MediaSourceEngine.prototype.bufferStart = function(contentType) {
  371.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  372.   if (contentType == ContentType.TEXT) {
  373.     return this.textEngine_.bufferStart();
  374.   }
  375.   return shaka.media.TimeRangesUtils.bufferStart(
  376.       this.getBuffered_(contentType));
  377. };
  380. /**
  381.  * Gets the last timestamp in buffer for the given content type.
  382.  *
  383.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  384.  * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  385.  */
  386. shaka.media.MediaSourceEngine.prototype.bufferEnd = function(contentType) {
  387.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  388.   if (contentType == ContentType.TEXT) {
  389.     return this.textEngine_.bufferEnd();
  390.   }
  391.   return shaka.media.TimeRangesUtils.bufferEnd(this.getBuffered_(contentType));
  392. };
  395. /**
  396.  * Determines if the given time is inside the buffered range of the given
  397.  * content type.
  398.  *
  399.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  400.  * @param {number} time Playhead time
  401.  * @param {number=} smallGapLimit
  402.  * @return {boolean}
  403.  */
  404. shaka.media.MediaSourceEngine.prototype.isBuffered = function(
  405.     contentType, time, smallGapLimit) {
  406.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  407.   if (contentType == ContentType.TEXT) {
  408.     return this.textEngine_.isBuffered(time);
  409.   } else {
  410.     let buffered = this.getBuffered_(contentType);
  411.     return shaka.media.TimeRangesUtils.isBuffered(
  412.                buffered, time, smallGapLimit);
  413.   }
  414. };
  417. /**
  418.  * Computes how far ahead of the given timestamp is buffered for the given
  419.  * content type.
  420.  *
  421.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  422.  * @param {number} time
  423.  * @return {number} The amount of time buffered ahead in seconds.
  424.  */
  425. shaka.media.MediaSourceEngine.prototype.bufferedAheadOf =
  426.     function(contentType, time) {
  427.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  428.   if (contentType == ContentType.TEXT) {
  429.     return this.textEngine_.bufferedAheadOf(time);
  430.   } else {
  431.     let buffered = this.getBuffered_(contentType);
  432.     return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  433.   }
  434. };
  437. /**
  438.  * Gets the current buffered ranges.
  439.  * @return {shakaExtern.BufferedInfo}
  440.  */
  441. shaka.media.MediaSourceEngine.prototype.getBufferedInfo = function() {
  442.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  443.   let getBufferedInfo = shaka.media.TimeRangesUtils.getBufferedInfo;
  445.   let textRanges;
  446.   if (this.textEngine_ && this.textEngine_.bufferStart() != null) {
  447.     textRanges = [{
  448.       start: this.textEngine_.bufferStart(),
  449.       end: this.textEngine_.bufferEnd()
  450.     }];
  451.   } else {
  452.     textRanges = [];
  453.   }
  455.   return {
  456.     total: getBufferedInfo(this.video_.buffered),
  457.     audio: getBufferedInfo(this.getBuffered_(ContentType.AUDIO)),
  458.     video: getBufferedInfo(this.getBuffered_(ContentType.VIDEO)),
  459.     text: textRanges
  460.   };
  461. };
  464. /**
  465.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  466.  * @return {TimeRanges} The buffered ranges for the given content type, or
  467.  *   null if the buffered ranges could not be obtained.
  468.  * @private
  469.  */
  470. shaka.media.MediaSourceEngine.prototype.getBuffered_ = function(contentType) {
  471.   try {
  472.     return this.sourceBuffers_[contentType].buffered;
  473.   } catch (exception) {
  474.     if (contentType in this.sourceBuffers_) {
  475.       // Note: previous MediaSource errors may cause access to |buffered| to
  476.       // throw.
  477.       shaka.log.error('failed to get buffered range for ' + contentType,
  478.                       exception);
  479.     }
  480.     return null;
  481.   }
  482. };
  485. /**
  486.  * Enqueue an operation to append data to the SourceBuffer.
  487.  * Start and end times are needed for TextEngine, but not for MediaSource.
  488.  * Start and end times may be null for initialization segments; if present they
  489.  * are relative to the presentation timeline.
  490.  *
  491.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  492.  * @param {!ArrayBuffer} data
  493.  * @param {?number} startTime relative to the start of the presentation
  494.  * @param {?number} endTime relative to the start of the presentation
  495.  * @return {!Promise}
  496.  */
  497. shaka.media.MediaSourceEngine.prototype.appendBuffer =
  498.     function(contentType, data, startTime, endTime) {
  499.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  501.   if (contentType == ContentType.TEXT) {
  502.     return this.textEngine_.appendBuffer(data, startTime, endTime);
  503.   } else if (this.transmuxers_[contentType]) {
  504.     return this.transmuxers_[contentType].transmux(data).then(
  505.         function(transmuxedData) {
  506.           // For CEA-608/708 CLOSED-CAPTIONS, text data is embedded in the
  507.           // video stream, so textEngine may not have been initialized.
  508.           if (!this.textEngine_) {
  509.             this.reinitText('text/vtt');
  510.           }
  511.           // This doesn't work for native TS support (ex. Edge/Chromecast),
  512.           // since no transmuxing is needed for native TS.
  513.           if (this.useEmbeddedText_) {
  514.             this.textEngine_.appendCues(transmuxedData.cues);
  515.           }
  516.           return this.enqueueOperation_(contentType,
  517.               this.append_.bind(this, contentType, transmuxedData.data.buffer));
  518.         }.bind(this));
  519.   } else {
  520.     return this.enqueueOperation_(
  521.         contentType,
  522.         this.append_.bind(this, contentType, data));
  523.   }
  524. };
  527. /**
  528.  * Set whether to use embedded text cues.
  529.  * Used for CEA 608/708 captions data, which is embedded inside the video
  530.  * stream.
  531.  *
  532.  * @param {boolean} useEmbeddedText
  533.  */
  534. shaka.media.MediaSourceEngine.prototype.setUseEmbeddedText =
  535.     function(useEmbeddedText) {
  536.   this.useEmbeddedText_ = useEmbeddedText;
  537. };
  540. /**
  541.  * Get whether we're using the embedded text cues.
  542.  *
  543.  * @return {boolean}
  544.  */
  545. shaka.media.MediaSourceEngine.prototype.getUseEmbeddedText = function() {
  546.   return this.useEmbeddedText_;
  547. };
  550. /**
  551.  * Enqueue an operation to remove data from the SourceBuffer.
  552.  *
  553.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  554.  * @param {number} startTime relative to the start of the presentation
  555.  * @param {number} endTime relative to the start of the presentation
  556.  * @return {!Promise}
  557.  */
  558. shaka.media.MediaSourceEngine.prototype.remove =
  559.     function(contentType, startTime, endTime) {
  560.   // On IE11, this operation would be permitted, but would have no effect!
  561.   // See https://github.com/google/shaka-player/issues/251
  562.   goog.asserts.assert(endTime < Number.MAX_VALUE,
  563.       'remove() with MAX_VALUE or Infinity is not IE-compatible!');
  564.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  565.   if (contentType == ContentType.TEXT) {
  566.     return this.textEngine_.remove(startTime, endTime);
  567.   }
  568.   return this.enqueueOperation_(
  569.       contentType,
  570.       this.remove_.bind(this, contentType, startTime, endTime));
  571. };
  574. /**
  575.  * Enqueue an operation to clear the SourceBuffer.
  576.  *
  577.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  578.  * @return {!Promise}
  579.  */
  580. shaka.media.MediaSourceEngine.prototype.clear = function(contentType) {
  581.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  582.   if (contentType == ContentType.TEXT) {
  583.     if (!this.textEngine_) {
  584.       return Promise.resolve();
  585.     }
  586.     return this.textEngine_.remove(0, Infinity);
  587.   }
  588.   // Note that not all platforms allow clearing to Infinity.
  589.   return this.enqueueOperation_(
  590.       contentType,
  591.       this.remove_.bind(this, contentType, 0, this.mediaSource_.duration));
  592. };
  595. /**
  596.  * Enqueue an operation to flush the SourceBuffer.
  597.  * This is a workaround for what we believe is a Chromecast bug.
  598.  *
  599.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  600.  * @return {!Promise}
  601.  */
  602. shaka.media.MediaSourceEngine.prototype.flush = function(contentType) {
  603.   // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  604.   // everything.
  605.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  606.   if (contentType == ContentType.TEXT) {
  607.     // Nothing to flush for text.
  608.     return Promise.resolve();
  609.   }
  610.   return this.enqueueOperation_(
  611.       contentType,
  612.       this.flush_.bind(this, contentType));
  613. };
  616. /**
  617.  * Sets the timestamp offset and append window end for the given content type.
  618.  *
  619.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  620.  * @param {number} timestampOffset The timestamp offset.  Segments which start
  621.  *   at time t will be inserted at time t + timestampOffset instead.  This
  622.  *   value does not affect segments which have already been inserted.
  623.  * @param {number} appendWindowStart The timestamp to set the append window
  624.  *   start to.  Media before this value will be truncated.
  625.  * @param {number} appendWindowEnd The timestamp to set the append window end
  626.  *   to.  Media beyond this value will be truncated.
  627.  * @return {!Promise}
  628.  */
  629. shaka.media.MediaSourceEngine.prototype.setStreamProperties = function(
  630.     contentType, timestampOffset, appendWindowStart, appendWindowEnd) {
  631.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  632.   if (contentType == ContentType.TEXT) {
  633.     this.textEngine_.setTimestampOffset(timestampOffset);
  634.     this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
  635.     return Promise.resolve();
  636.   }
  638.   return Promise.all([
  639.     // Queue an abort() to help MSE splice together overlapping segments.
  640.     // We set appendWindowEnd when we change periods in DASH content, and the
  641.     // period transition may result in overlap.
  642.     //
  643.     // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  644.     // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  645.     // timestamp offset.  By calling abort(), we reset the state so we can
  646.     // set it.
  647.     this.enqueueOperation_(
  648.         contentType,
  649.         this.abort_.bind(this, contentType)),
  650.     this.enqueueOperation_(
  651.         contentType,
  652.         this.setTimestampOffset_.bind(this, contentType, timestampOffset)),
  653.     this.enqueueOperation_(
  654.         contentType,
  655.         this.setAppendWindow_.bind(
  656.             this, contentType, appendWindowStart, appendWindowEnd))
  657.   ]);
  658. };
  661. /**
  662.  * @param {string=} opt_reason Valid reasons are 'network' and 'decode'.
  663.  * @return {!Promise}
  664.  * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  665.  */
  666. shaka.media.MediaSourceEngine.prototype.endOfStream = function(opt_reason) {
  667.   return this.enqueueBlockingOperation_(function() {
  668.     // Chrome won't let us pass undefined, but it will let us omit the
  669.     // argument.  Firefox does not have this problem.
  670.     // TODO: File a bug about this.
  671.     if (opt_reason) {
  672.       this.mediaSource_.endOfStream(opt_reason);
  673.     } else {
  674.       this.mediaSource_.endOfStream();
  675.     }
  676.   }.bind(this));
  677. };
  680. /**
  681.  * We only support increasing duration at this time.  Decreasing duration
  682.  * causes the MSE removal algorithm to run, which results in an 'updateend'
  683.  * event.  Supporting this scenario would be complicated, and is not currently
  684.  * needed.
  685.  *
  686.  * @param {number} duration
  687.  * @return {!Promise}
  688.  */
  689. shaka.media.MediaSourceEngine.prototype.setDuration = function(duration) {
  690.   goog.asserts.assert(
  691.       isNaN(this.mediaSource_.duration) ||
  692.           this.mediaSource_.duration <= duration,
  693.       'duration cannot decrease: ' + this.mediaSource_.duration + ' -> ' +
  694.           duration);
  695.   return this.enqueueBlockingOperation_(function() {
  696.     this.mediaSource_.duration = duration;
  697.   }.bind(this));
  698. };
  701. /**
  702.  * Get the current MediaSource duration.
  703.  *
  704.  * @return {number}
  705.  */
  706. shaka.media.MediaSourceEngine.prototype.getDuration = function() {
  707.   return this.mediaSource_.duration;
  708. };
  711. /**
  712.  * Append data to the SourceBuffer.
  713.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  714.  * @param {!ArrayBuffer} data
  715.  * @throws QuotaExceededError if the browser's buffer is full
  716.  * @private
  717.  */
  718. shaka.media.MediaSourceEngine.prototype.append_ =
  719.     function(contentType, data) {
  720.   // This will trigger an 'updateend' event.
  721.   this.sourceBuffers_[contentType].appendBuffer(data);
  722. };
  725. /**
  726.  * Remove data from the SourceBuffer.
  727.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  728.  * @param {number} startTime relative to the start of the presentation
  729.  * @param {number} endTime relative to the start of the presentation
  730.  * @private
  731.  */
  732. shaka.media.MediaSourceEngine.prototype.remove_ =
  733.     function(contentType, startTime, endTime) {
  734.   if (endTime <= startTime) {
  735.     // Ignore removal of inverted or empty ranges.
  736.     // Fake 'updateend' event to resolve the operation.
  737.     this.onUpdateEnd_(contentType);
  738.     return;
  739.   }
  741.   // This will trigger an 'updateend' event.
  742.   this.sourceBuffers_[contentType].remove(startTime, endTime);
  743. };
  746. /**
  747.  * Call abort() on the SourceBuffer.
  748.  * This resets MSE's last_decode_timestamp on all track buffers, which should
  749.  * trigger the splicing logic for overlapping segments.
  750.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  751.  * @private
  752.  */
  753. shaka.media.MediaSourceEngine.prototype.abort_ = function(contentType) {
  754.   // Save the append window, which is reset on abort().
  755.   let appendWindowStart = this.sourceBuffers_[contentType].appendWindowStart;
  756.   let appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
  758.   // This will not trigger an 'updateend' event, since nothing is happening.
  759.   // This is only to reset MSE internals, not to abort an actual operation.
  760.   this.sourceBuffers_[contentType].abort();
  762.   // Restore the append window.
  763.   this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  764.   this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  766.   // Fake an 'updateend' event to resolve the operation.
  767.   this.onUpdateEnd_(contentType);
  768. };
  771. /**
  772.  * Nudge the playhead to force the media pipeline to be flushed.
  773.  * This seems to be necessary on Chromecast to get new content to replace old
  774.  * content.
  775.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  776.  * @private
  777.  */
  778. shaka.media.MediaSourceEngine.prototype.flush_ = function(contentType) {
  779.   // Never use flush_ if there's data.  It causes a hiccup in playback.
  780.   goog.asserts.assert(
  781.       this.video_.buffered.length == 0,
  782.       'MediaSourceEngine.flush_ should only be used after clearing all data!');
  784.   // Seeking forces the pipeline to be flushed.
  785.   this.video_.currentTime -= 0.001;
  787.   // Fake an 'updateend' event to resolve the operation.
  788.   this.onUpdateEnd_(contentType);
  789. };
  792. /**
  793.  * Set the SourceBuffer's timestamp offset.
  794.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  795.  * @param {number} timestampOffset
  796.  * @private
  797.  */
  798. shaka.media.MediaSourceEngine.prototype.setTimestampOffset_ =
  799.     function(contentType, timestampOffset) {
  800.   // Work around for https://github.com/google/shaka-player/issues/1281:
  801.   // TODO(https://goo.gl/3ZTzse): follow up when this is fixed in Edge
  802.   if (timestampOffset < 0) {
  803.     // Try to prevent rounding errors in Edge from removing the first keyframe.
  804.     timestampOffset += 0.001;
  805.   }
  807.   this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
  809.   // Fake an 'updateend' event to resolve the operation.
  810.   this.onUpdateEnd_(contentType);
  811. };
  814. /**
  815.  * Set the SourceBuffer's append window end.
  816.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  817.  * @param {number} appendWindowStart
  818.  * @param {number} appendWindowEnd
  819.  * @private
  820.  */
  821. shaka.media.MediaSourceEngine.prototype.setAppendWindow_ =
  822.     function(contentType, appendWindowStart, appendWindowEnd) {
  823.   // You can't set start > end, so first set start to 0, then set the new end,
  824.   // then set the new start.  That way, there are no intermediate states which
  825.   // are invalid.
  826.   this.sourceBuffers_[contentType].appendWindowStart = 0;
  827.   this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  828.   this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  830.   // Fake an 'updateend' event to resolve the operation.
  831.   this.onUpdateEnd_(contentType);
  832. };
  835. /**
  836.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  837.  * @param {!Event} event
  838.  * @private
  839.  */
  840. shaka.media.MediaSourceEngine.prototype.onError_ =
  841.     function(contentType, event) {
  842.   let operation = this.queues_[contentType][0];
  843.   goog.asserts.assert(operation, 'Spurious error event!');
  844.   goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  845.                       'SourceBuffer should not be updating on error!');
  846.   let code = this.video_.error ? this.video_.error.code : 0;
  847.   operation.p.reject(new shaka.util.Error(
  848.       shaka.util.Error.Severity.CRITICAL,
  849.       shaka.util.Error.Category.MEDIA,
  850.       shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  851.       code));
  852.   // Do not pop from queue.  An 'updateend' event will fire next, and to avoid
  853.   // synchronizing these two event handlers, we will allow that one to pop from
  854.   // the queue as normal.  Note that because the operation has already been
  855.   // rejected, the call to resolve() in the 'updateend' handler will have no
  856.   // effect.
  857. };
  860. /**
  861.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  862.  * @private
  863.  */
  864. shaka.media.MediaSourceEngine.prototype.onUpdateEnd_ = function(contentType) {
  865.   let operation = this.queues_[contentType][0];
  866.   goog.asserts.assert(operation, 'Spurious updateend event!');
  867.   if (!operation) return;
  868.   goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  869.                       'SourceBuffer should not be updating on updateend!');
  870.   operation.p.resolve();
  871.   this.popFromQueue_(contentType);
  872. };
  875. /**
  876.  * Enqueue an operation and start it if appropriate.
  877.  *
  878.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  879.  * @param {function()} start
  880.  * @return {!Promise}
  881.  * @private
  882.  */
  883. shaka.media.MediaSourceEngine.prototype.enqueueOperation_ =
  884.     function(contentType, start) {
  885.   if (this.destroyed_) return Promise.reject();
  887.   let operation = {
  888.     start: start,
  889.     p: new shaka.util.PublicPromise()
  890.   };
  891.   this.queues_[contentType].push(operation);
  893.   if (this.queues_[contentType].length == 1) {
  894.     try {
  895.       operation.start();
  896.     } catch (exception) {
  897.       if (exception.name == 'QuotaExceededError') {
  898.         operation.p.reject(new shaka.util.Error(
  899.             shaka.util.Error.Severity.CRITICAL,
  900.             shaka.util.Error.Category.MEDIA,
  901.             shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  902.             contentType));
  903.       } else {
  904.         operation.p.reject(new shaka.util.Error(
  905.             shaka.util.Error.Severity.CRITICAL,
  906.             shaka.util.Error.Category.MEDIA,
  907.             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  908.             exception));
  909.       }
  910.       this.popFromQueue_(contentType);
  911.     }
  912.   }
  913.   return operation.p;
  914. };
  917. /**
  918.  * Enqueue an operation which must block all other operations on all
  919.  * SourceBuffers.
  920.  *
  921.  * @param {function()} run
  922.  * @return {!Promise}
  923.  * @private
  924.  */
  925. shaka.media.MediaSourceEngine.prototype.enqueueBlockingOperation_ =
  926.     function(run) {
  927.   if (this.destroyed_) return Promise.reject();
  929.   let allWaiters = [];
  931.   // Enqueue a 'wait' operation onto each queue.
  932.   // This operation signals its readiness when it starts.
  933.   // When all wait operations are ready, the real operation takes place.
  934.   for (let contentType in this.sourceBuffers_) {
  935.     let ready = new shaka.util.PublicPromise();
  936.     let operation = {
  937.       start: function(ready) { ready.resolve(); }.bind(null, ready),
  938.       p: ready
  939.     };
  941.     this.queues_[contentType].push(operation);
  942.     allWaiters.push(ready);
  944.     if (this.queues_[contentType].length == 1) {
  945.       operation.start();
  946.     }
  947.   }
  949.   // Return a Promise to the real operation, which waits to begin until there
  950.   // are no other in-progress operations on any SourceBuffers.
  951.   return Promise.all(allWaiters).then(function() {
  952.     if (goog.DEBUG) {
  953.       // If we did it correctly, nothing is updating.
  954.       for (let contentType in this.sourceBuffers_) {
  955.         goog.asserts.assert(
  956.             this.sourceBuffers_[contentType].updating == false,
  957.             'SourceBuffers should not be updating after a blocking op!');
  958.       }
  959.     }
  961.     let ret;
  962.     // Run the real operation, which is synchronous.
  963.     try {
  964.       run();
  965.     } catch (exception) {
  966.       ret = Promise.reject(new shaka.util.Error(
  967.           shaka.util.Error.Severity.CRITICAL,
  968.           shaka.util.Error.Category.MEDIA,
  969.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  970.           exception));
  971.     }
  973.     // Unblock the queues.
  974.     for (let contentType in this.sourceBuffers_) {
  975.       this.popFromQueue_(contentType);
  976.     }
  978.     return ret;
  979.   }.bind(this), function() {
  980.     // One of the waiters failed, which means we've been destroyed.
  981.     goog.asserts.assert(this.destroyed_, 'Should be destroyed by now');
  982.     // We haven't popped from the queue.  Canceled waiters have been removed by
  983.     // destroy.  What's left now should just be resolved waiters.  In uncompiled
  984.     // mode, we will maintain good hygiene and make sure the assert at the end
  985.     // of destroy passes.  In compiled mode, the queues are wiped in destroy.
  986.     if (goog.DEBUG) {
  987.       for (let contentType in this.sourceBuffers_) {
  988.         if (this.queues_[contentType].length) {
  989.           goog.asserts.assert(
  990.               this.queues_[contentType].length == 1,
  991.               'Should be at most one item in queue!');
  992.           goog.asserts.assert(
  993.               allWaiters.indexOf(this.queues_[contentType][0].p) != -1,
  994.               'The item in queue should be one of our waiters!');
  995.           this.queues_[contentType].shift();
  996.         }
  997.       }
  998.     }
  999.     return Promise.reject();
  1000.   }.bind(this));
  1001. };
  1004. /**
  1005.  * Pop from the front of the queue and start a new operation.
  1006.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1007.  * @private
  1008.  */
  1009. shaka.media.MediaSourceEngine.prototype.popFromQueue_ = function(contentType) {
  1010.   // Remove the in-progress operation, which is now complete.
  1011.   this.queues_[contentType].shift();
  1012.   // Retrieve the next operation, if any, from the queue and start it.
  1013.   let next = this.queues_[contentType][0];
  1014.   if (next) {
  1015.     try {
  1016.       next.start();
  1017.     } catch (exception) {
  1018.       next.p.reject(new shaka.util.Error(
  1019.           shaka.util.Error.Severity.CRITICAL,
  1020.           shaka.util.Error.Category.MEDIA,
  1021.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1022.           exception));
  1023.       this.popFromQueue_(contentType);
  1024.     }
  1025.   }
  1026. };