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.TextEngine');
  23. goog.require('shaka.media.TimeRangesUtils');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.EventManager');
  26. goog.require('shaka.util.Functional');
  27. goog.require('shaka.util.IDestroyable');
  28. goog.require('shaka.util.ManifestParserUtils');
  29. goog.require('shaka.util.PublicPromise');
  33. /**
  34.  * MediaSourceEngine wraps all operations on MediaSource and SourceBuffers.
  35.  * All asynchronous operations return a Promise, and all operations are
  36.  * internally synchronized and serialized as needed.  Operations that can
  37.  * be done in parallel will be done in parallel.
  38.  *
  39.  * @param {HTMLMediaElement} video The video element, used to read error codes
  40.  *   when MediaSource operations fail.
  41.  * @param {MediaSource} mediaSource The MediaSource, which must be in the
  42.  *   'open' state.
  43.  * @param {TextTrack} textTrack The TextTrack to use for subtitles/captions.
  44.  *
  45.  * @struct
  46.  * @constructor
  47.  * @implements {shaka.util.IDestroyable}
  48.  */
  49. shaka.media.MediaSourceEngine = function(video, mediaSource, textTrack) {
  50.   goog.asserts.assert(mediaSource.readyState == 'open',
  51.                       'The MediaSource should be in the \'open\' state.');
  53.   /** @private {HTMLMediaElement} */
  54.   this.video_ = video;
  56.   /** @private {MediaSource} */
  57.   this.mediaSource_ = mediaSource;
  59.   /** @private {TextTrack} */
  60.   this.textTrack_ = textTrack;
  62.   /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  63.                          SourceBuffer>} */
  64.   this.sourceBuffers_ = {};
  66.   /** @private {shaka.media.TextEngine} */
  67.   this.textEngine_ = null;
  69.   /**
  70.    * @private {!Object.<string,
  71.    *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
  72.    */
  73.   this.queues_ = {};
  75.   /** @private {shaka.util.EventManager} */
  76.   this.eventManager_ = new shaka.util.EventManager();
  78.   /** @private {boolean} */
  79.   this.destroyed_ = false;
  80. };
  83. /**
  84.  * @typedef {{
  85.  *   start: function(),
  86.  *   p: !shaka.util.PublicPromise
  87.  * }}
  88.  *
  89.  * @summary An operation in queue.
  90.  * @property {function()} start
  91.  *   The function which starts the operation.
  92.  * @property {!shaka.util.PublicPromise} p
  93.  *   The PublicPromise which is associated with this operation.
  94.  */
  95. shaka.media.MediaSourceEngine.Operation;
  98. /**
  99.  * Checks if a certain type is supported.
  100.  *
  101.  * @param {string} mimeType
  102.  * @return {boolean}
  103.  */
  104. shaka.media.MediaSourceEngine.isTypeSupported = function(mimeType) {
  105.   return shaka.media.TextEngine.isTypeSupported(mimeType) ||
  106.          MediaSource.isTypeSupported(mimeType);
  107. };
  110. /**
  111.  * Returns true if the browser has the basic APIs we need.
  112.  *
  113.  * @return {boolean}
  114.  */
  115. shaka.media.MediaSourceEngine.isBrowserSupported = function() {
  116.   return !!window.MediaSource;
  117. };
  120. /**
  121.  * Returns a map of MediaSource support for well-known types.
  122.  *
  123.  * @return {!Object.<string, boolean>}
  124.  */
  125. shaka.media.MediaSourceEngine.probeSupport = function() {
  126.   goog.asserts.assert(shaka.media.MediaSourceEngine.isBrowserSupported(),
  127.                       'Requires basic support');
  128.   var support = {};
  129.   var testMimeTypes = [
  130.     // MP4 types
  131.     'video/mp4; codecs="avc1.42E01E"',
  132.     'video/mp4; codecs="avc3.42E01E"',
  133.     'video/mp4; codecs="hvc1.1.6.L93.90"',
  134.     'audio/mp4; codecs="mp4a.40.2"',
  135.     'audio/mp4; codecs="ac-3"',
  136.     'audio/mp4; codecs="ec-3"',
  137.     // WebM types
  138.     'video/webm; codecs="vp8"',
  139.     'video/webm; codecs="vp9"',
  140.     'video/webm; codecs="av1"',
  141.     'audio/webm; codecs="vorbis"',
  142.     'audio/webm; codecs="opus"',
  143.     // MPEG2 TS types (video/ is also used for audio: http://goo.gl/tYHXiS)
  144.     'video/mp2t; codecs="avc1.42E01E"',
  145.     'video/mp2t; codecs="avc3.42E01E"',
  146.     'video/mp2t; codecs="hvc1.1.6.L93.90"',
  147.     'video/mp2t; codecs="mp4a.40.2"',
  148.     'video/mp2t; codecs="ac-3"',
  149.     'video/mp2t; codecs="ec-3"',
  150.     'video/mp2t; codecs="mp4a.40.2"',
  151.     // WebVTT types
  152.     'text/vtt',
  153.     'application/mp4; codecs="wvtt"',
  154.     // TTML types
  155.     'application/ttml+xml',
  156.     'application/mp4; codecs="stpp"'
  157.   ];
  159.   testMimeTypes.forEach(function(type) {
  160.     support[type] = shaka.media.MediaSourceEngine.isTypeSupported(type);
  161.     var basicType = type.split(';')[0];
  162.     support[basicType] = support[basicType] || support[type];
  163.   });
  165.   return support;
  166. };
  169. /**
  170.  * @override
  171.  */
  172. shaka.media.MediaSourceEngine.prototype.destroy = function() {
  173.   var Functional = shaka.util.Functional;
  174.   this.destroyed_ = true;
  176.   var cleanup = [];
  178.   for (var contentType in this.queues_) {
  179.     // Make a local copy of the queue and the first item.
  180.     var q = this.queues_[contentType];
  181.     var inProgress = q[0];
  183.     // Drop everything else out of the queue.
  184.     this.queues_[contentType] = q.slice(0, 1);
  186.     // We will wait for this item to complete/fail.
  187.     if (inProgress) {
  188.       cleanup.push(inProgress.p.catch(Functional.noop));
  189.     }
  191.     // The rest will be rejected silently if possible.
  192.     for (var i = 1; i < q.length; ++i) {
  193.       q[i].p.catch(Functional.noop);
  194.       q[i].p.reject();
  195.     }
  196.   }
  198.   if (this.textEngine_) {
  199.     cleanup.push(this.textEngine_.destroy());
  200.   }
  202.   return Promise.all(cleanup).then(function() {
  203.     this.eventManager_.destroy();
  204.     this.eventManager_ = null;
  205.     this.video_ = null;
  206.     this.mediaSource_ = null;
  207.     this.textTrack_ = null;
  208.     this.textEngine_ = null;
  209.     this.sourceBuffers_ = {};
  210.     if (!COMPILED) {
  211.       for (var contentType in this.queues_) {
  212.         goog.asserts.assert(
  213.             this.queues_[contentType].length == 0,
  214.             contentType + ' queue should be empty after destroy!');
  215.       }
  216.     }
  217.     this.queues_ = {};
  218.   }.bind(this));
  219. };
  222. /**
  223.  * Initialize MediaSourceEngine.
  224.  *
  225.  * Note that it is not valid to call this multiple times, except to add or
  226.  * reinitialize text streams.
  227.  *
  228.  * @param {!Object.<shaka.util.ManifestParserUtils.ContentType, string>}
  229.  *   typeConfig A map of content types to full MIME types.
  230.  *   For example: { 'audio': 'audio/webm; codecs="vorbis"',
  231.  *   'video': 'video/webm; codecs="vp9"', 'text': 'text/vtt' }.
  232.  *   All types given must be supported.
  233.  *
  234.  * @throws InvalidAccessError if blank MIME types are given
  235.  * @throws NotSupportedError if unsupported MIME types are given
  236.  * @throws QuotaExceededError if the browser can't support that many buffers
  237.  */
  238. shaka.media.MediaSourceEngine.prototype.init = function(typeConfig) {
  239.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  241.   for (var contentType in typeConfig) {
  242.     var mimeType = typeConfig[contentType];
  243.     goog.asserts.assert(
  244.         shaka.media.MediaSourceEngine.isTypeSupported(mimeType),
  245.         'Type negotiation should happen before MediaSourceEngine.init!');
  247.     if (contentType == ContentType.TEXT) {
  248.       this.reinitText(mimeType);
  249.     } else {
  250.       var sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
  251.       this.eventManager_.listen(
  252.           sourceBuffer, 'error', this.onError_.bind(this, contentType));
  253.       this.eventManager_.listen(
  254.           sourceBuffer, 'updateend', this.onUpdateEnd_.bind(this, contentType));
  255.       this.sourceBuffers_[contentType] = sourceBuffer;
  256.       this.queues_[contentType] = [];
  257.     }
  258.   }
  259. };
  262. /**
  263.  * Reinitialize the TextEngine for a new text type.
  264.  * @param {string} mimeType
  265.  */
  266. shaka.media.MediaSourceEngine.prototype.reinitText = function(mimeType) {
  267.   if (!this.textEngine_) {
  268.     this.textEngine_ = new shaka.media.TextEngine(this.textTrack_);
  269.   }
  270.   this.textEngine_.initParser(mimeType);
  271. };
  274. /**
  275.  * Gets the first timestamp in buffer for the given content type.
  276.  *
  277.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  278.  * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  279.  */
  280. shaka.media.MediaSourceEngine.prototype.bufferStart = function(contentType) {
  281.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  282.   if (contentType == ContentType.TEXT) {
  283.     return this.textEngine_.bufferStart();
  284.   }
  285.   return shaka.media.TimeRangesUtils.bufferStart(
  286.       this.getBuffered_(contentType));
  287. };
  290. /**
  291.  * Gets the last timestamp in buffer for the given content type.
  292.  *
  293.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  294.  * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  295.  */
  296. shaka.media.MediaSourceEngine.prototype.bufferEnd = function(contentType) {
  297.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  298.   if (contentType == ContentType.TEXT) {
  299.     return this.textEngine_.bufferEnd();
  300.   }
  301.   return shaka.media.TimeRangesUtils.bufferEnd(this.getBuffered_(contentType));
  302. };
  305. /**
  306.  * Determines if the given time is inside the buffered range of the given
  307.  * content type.
  308.  *
  309.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  310.  * @param {number} time
  311.  * @return {boolean}
  312.  */
  313. shaka.media.MediaSourceEngine.prototype.isBuffered = function(
  314.     contentType, time) {
  315.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  316.   if (contentType == ContentType.TEXT) {
  317.     return this.textEngine_.isBuffered(time);
  318.   } else {
  319.     var buffered = this.getBuffered_(contentType);
  320.     return shaka.media.TimeRangesUtils.isBuffered(buffered, time);
  321.   }
  322. };
  325. /**
  326.  * Computes how far ahead of the given timestamp is buffered for the given
  327.  * content type.
  328.  *
  329.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  330.  * @param {number} time
  331.  * @return {number} The amount of time buffered ahead in seconds.
  332.  */
  333. shaka.media.MediaSourceEngine.prototype.bufferedAheadOf =
  334.     function(contentType, time) {
  335.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  336.   if (contentType == ContentType.TEXT) {
  337.     return this.textEngine_.bufferedAheadOf(time);
  338.   } else {
  339.     var buffered = this.getBuffered_(contentType);
  340.     return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  341.   }
  342. };
  345. /**
  346.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  347.  * @return {TimeRanges} The buffered ranges for the given content type, or
  348.  *   null if the buffered ranges could not be obtained.
  349.  * @private
  350.  */
  351. shaka.media.MediaSourceEngine.prototype.getBuffered_ = function(contentType) {
  352.   try {
  353.     return this.sourceBuffers_[contentType].buffered;
  354.   } catch (exception) {
  355.     // Note: previous MediaSource errors may cause access to |buffered| to
  356.     // throw.
  357.     shaka.log.error('failed to get buffered range for ' + contentType,
  358.                     exception);
  359.     return null;
  360.   }
  361. };
  364. /**
  365.  * Enqueue an operation to append data to the SourceBuffer.
  366.  * Start and end times are needed for TextEngine, but not for MediaSource.
  367.  * Start and end times may be null for initialization segments, if present they
  368.  * are relative to the presentation timeline.
  369.  *
  370.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  371.  * @param {!ArrayBuffer} data
  372.  * @param {?number} startTime
  373.  * @param {?number} endTime
  374.  * @return {!Promise}
  375.  */
  376. shaka.media.MediaSourceEngine.prototype.appendBuffer =
  377.     function(contentType, data, startTime, endTime) {
  378.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  379.   if (contentType == ContentType.TEXT) {
  380.     return this.textEngine_.appendBuffer(data, startTime, endTime);
  381.   }
  382.   return this.enqueueOperation_(
  383.       contentType,
  384.       this.append_.bind(this, contentType, data));
  385. };
  388. /**
  389.  * Enqueue an operation to remove data from the SourceBuffer.
  390.  *
  391.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  392.  * @param {number} startTime
  393.  * @param {number} endTime
  394.  * @return {!Promise}
  395.  */
  396. shaka.media.MediaSourceEngine.prototype.remove =
  397.     function(contentType, startTime, endTime) {
  398.   // On IE11, this operation would be permitted, but would have no effect!
  399.   // See https://github.com/google/shaka-player/issues/251
  400.   goog.asserts.assert(endTime < Number.MAX_VALUE,
  401.       'remove() with MAX_VALUE or Infinity is not IE-compatible!');
  402.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  403.   if (contentType == ContentType.TEXT) {
  404.     return this.textEngine_.remove(startTime, endTime);
  405.   }
  406.   return this.enqueueOperation_(
  407.       contentType,
  408.       this.remove_.bind(this, contentType, startTime, endTime));
  409. };
  412. /**
  413.  * Enqueue an operation to clear the SourceBuffer.
  414.  *
  415.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  416.  * @return {!Promise}
  417.  */
  418. shaka.media.MediaSourceEngine.prototype.clear = function(contentType) {
  419.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  420.   if (contentType == ContentType.TEXT) {
  421.     return this.textEngine_.remove(0, Infinity);
  422.   }
  423.   // Note that not all platforms allow clearing to Infinity.
  424.   return this.enqueueOperation_(
  425.       contentType,
  426.       this.remove_.bind(this, contentType, 0, this.mediaSource_.duration));
  427. };
  430. /**
  431.  * Enqueue an operation to flush the SourceBuffer.
  432.  * This is a workaround for what we believe is a Chromecast bug.
  433.  *
  434.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  435.  * @return {!Promise}
  436.  */
  437. shaka.media.MediaSourceEngine.prototype.flush = function(contentType) {
  438.   // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  439.   // everything.
  440.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  441.   if (contentType == ContentType.TEXT) {
  442.     // Nothing to flush for text.
  443.     return Promise.resolve();
  444.   }
  445.   return this.enqueueOperation_(
  446.       contentType,
  447.       this.flush_.bind(this, contentType));
  448. };
  451. /**
  452.  * Sets the timestamp offset and append window end for the given content type.
  453.  *
  454.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  455.  * @param {number} timestampOffset The timestamp offset. Segments which start
  456.  *   at time t will be inserted at time t + timestampOffset instead. This
  457.  *   value does not affect segments which have already been inserted.
  458.  * @param {?number} appendWindowEnd The timestamp to set the append window end
  459.  *   to. Media beyond this value will be truncated.
  460.  * @return {!Promise}
  461.  */
  462. shaka.media.MediaSourceEngine.prototype.setStreamProperties = function(
  463.     contentType, timestampOffset, appendWindowEnd) {
  464.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  465.   if (contentType == ContentType.TEXT) {
  466.     this.textEngine_.setTimestampOffset(timestampOffset);
  467.     if (appendWindowEnd != null)
  468.       this.textEngine_.setAppendWindowEnd(appendWindowEnd);
  469.     return Promise.resolve();
  470.   }
  472.   if (appendWindowEnd == null)
  473.     appendWindowEnd = Infinity;
  475.   return Promise.all([
  476.     // Queue an abort() to help MSE splice together overlapping segments.
  477.     // We set appendWindowEnd when we change periods in DASH content, and the
  478.     // period transition may result in overlap.
  479.     //
  480.     // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  481.     // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  482.     // timestamp offset.  By calling abort(), we reset the state so we can
  483.     // set it.
  484.     //
  485.     // Note that abort() resets both appendWindowStart and appendWindowEnd;
  486.     // however, we don't use appendWindowStart.
  487.     this.enqueueOperation_(
  488.         contentType,
  489.         this.abort_.bind(this, contentType)),
  490.     this.enqueueOperation_(
  491.         contentType,
  492.         this.setTimestampOffset_.bind(this, contentType, timestampOffset)),
  493.     this.enqueueOperation_(
  494.         contentType,
  495.         this.setAppendWindowEnd_.bind(this, contentType, appendWindowEnd))
  496.   ]);
  497. };
  500. /**
  501.  * @param {string=} opt_reason Valid reasons are 'network' and 'decode'.
  502.  * @return {!Promise}
  503.  * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  504.  */
  505. shaka.media.MediaSourceEngine.prototype.endOfStream = function(opt_reason) {
  506.   return this.enqueueBlockingOperation_(function() {
  507.     // Chrome won't let me pass undefined, but it will let me omit the
  508.     // argument.  Firefox does not have this problem.
  509.     // TODO: File a bug about this.
  510.     if (opt_reason) {
  511.       this.mediaSource_.endOfStream(opt_reason);
  512.     } else {
  513.       this.mediaSource_.endOfStream();
  514.     }
  515.   }.bind(this));
  516. };
  519. /**
  520.  * We only support increasing duration at this time.  Decreasing duration
  521.  * causes the MSE removal algorithm to run, which results in an 'updateend'
  522.  * event.  Supporting this scenario would be complicated, and is not currently
  523.  * needed.
  524.  *
  525.  * @param {number} duration
  526.  * @return {!Promise}
  527.  */
  528. shaka.media.MediaSourceEngine.prototype.setDuration = function(duration) {
  529.   goog.asserts.assert(
  530.       isNaN(this.mediaSource_.duration) ||
  531.           this.mediaSource_.duration <= duration,
  532.       'duration cannot decrease: ' + this.mediaSource_.duration + ' -> ' +
  533.           duration);
  534.   return this.enqueueBlockingOperation_(function() {
  535.     this.mediaSource_.duration = duration;
  536.   }.bind(this));
  537. };
  540. /**
  541.  * Get the current MediaSource duration.
  542.  *
  543.  * @return {number}
  544.  */
  545. shaka.media.MediaSourceEngine.prototype.getDuration = function() {
  546.   return this.mediaSource_.duration;
  547. };
  550. /**
  551.  * Append data to the SourceBuffer.
  552.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  553.  * @param {!ArrayBuffer} data
  554.  * @throws QuotaExceededError if the browser's buffer is full
  555.  * @private
  556.  */
  557. shaka.media.MediaSourceEngine.prototype.append_ =
  558.     function(contentType, data) {
  559.   // This will trigger an 'updateend' event.
  560.   this.sourceBuffers_[contentType].appendBuffer(data);
  561. };
  564. /**
  565.  * Remove data from the SourceBuffer.
  566.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  567.  * @param {number} startTime
  568.  * @param {number} endTime
  569.  * @private
  570.  */
  571. shaka.media.MediaSourceEngine.prototype.remove_ =
  572.     function(contentType, startTime, endTime) {
  573.   if (endTime <= startTime) {
  574.     // Ignore removal of inverted or empty ranges.
  575.     // Fake 'updateend' event to resolve the operation.
  576.     this.onUpdateEnd_(contentType);
  577.     return;
  578.   }
  580.   // This will trigger an 'updateend' event.
  581.   this.sourceBuffers_[contentType].remove(startTime, endTime);
  582. };
  585. /**
  586.  * Call abort() on the SourceBuffer.
  587.  * This resets MSE's last_decode_timestamp on all track buffers, which should
  588.  * trigger the splicing logic for overlapping segments.
  589.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  590.  * @private
  591.  */
  592. shaka.media.MediaSourceEngine.prototype.abort_ = function(contentType) {
  593.   // Save the append window end, which is reset on abort().
  594.   var appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
  596.   // This will not trigger an 'updateend' event, since nothing is happening.
  597.   // This is only to reset MSE internals, not to abort an actual operation.
  598.   this.sourceBuffers_[contentType].abort();
  600.   // Restore the append window end.
  601.   this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  603.   // Fake 'updateend' event to resolve the operation.
  604.   this.onUpdateEnd_(contentType);
  605. };
  608. /**
  609.  * Nudge the playhead to force the media pipeline to be flushed.
  610.  * This seems to be necessary on Chromecast to get new content to replace old
  611.  * content.
  612.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  613.  * @private
  614.  */
  615. shaka.media.MediaSourceEngine.prototype.flush_ = function(contentType) {
  616.   // Never use flush_ if there's data.  It causes a hiccup in playback.
  617.   goog.asserts.assert(
  618.       this.video_.buffered.length == 0,
  619.       'MediaSourceEngine.flush_ should only be used after clearing all data!');
  621.   // Seeking forces the pipeline to be flushed.
  622.   this.video_.currentTime -= 0.001;
  624.   // Fake 'updateend' event to resolve the operation.
  625.   this.onUpdateEnd_(contentType);
  626. };
  629. /**
  630.  * Set the SourceBuffer's timestamp offset.
  631.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  632.  * @param {number} timestampOffset
  633.  * @private
  634.  */
  635. shaka.media.MediaSourceEngine.prototype.setTimestampOffset_ =
  636.     function(contentType, timestampOffset) {
  637.   this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
  639.   // Fake 'updateend' event to resolve the operation.
  640.   this.onUpdateEnd_(contentType);
  641. };
  644. /**
  645.  * Set the SourceBuffer's append window end.
  646.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  647.  * @param {number} appendWindowEnd
  648.  * @private
  649.  */
  650. shaka.media.MediaSourceEngine.prototype.setAppendWindowEnd_ =
  651.     function(contentType, appendWindowEnd) {
  652.   var fudge = 1 / 25;  // one frame, assuming a low framerate
  653.   this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd + fudge;
  655.   // Fake 'updateend' event to resolve the operation.
  656.   this.onUpdateEnd_(contentType);
  657. };
  660. /**
  661.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  662.  * @param {!Event} event
  663.  * @private
  664.  */
  665. shaka.media.MediaSourceEngine.prototype.onError_ =
  666.     function(contentType, event) {
  667.   var operation = this.queues_[contentType][0];
  668.   goog.asserts.assert(operation, 'Spurious error event!');
  669.   goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  670.                       'SourceBuffer should not be updating on error!');
  671.   var code = this.video_.error ? this.video_.error.code : 0;
  672.   operation.p.reject(new shaka.util.Error(
  673.       shaka.util.Error.Severity.CRITICAL,
  674.       shaka.util.Error.Category.MEDIA,
  675.       shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  676.       code));
  677.   // Do not pop from queue.  An 'updateend' event will fire next, and to avoid
  678.   // synchronizing these two event handlers, we will allow that one to pop from
  679.   // the queue as normal.  Note that because the operation has already been
  680.   // rejected, the call to resolve() in the 'updateend' handler will have no
  681.   // effect.
  682. };
  685. /**
  686.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  687.  * @private
  688.  */
  689. shaka.media.MediaSourceEngine.prototype.onUpdateEnd_ = function(contentType) {
  690.   var operation = this.queues_[contentType][0];
  691.   goog.asserts.assert(operation, 'Spurious updateend event!');
  692.   if (!operation) return;
  693.   goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  694.                       'SourceBuffer should not be updating on updateend!');
  695.   operation.p.resolve();
  696.   this.popFromQueue_(contentType);
  697. };
  700. /**
  701.  * Enqueue an operation and start it if appropriate.
  702.  *
  703.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  704.  * @param {function()} start
  705.  * @return {!Promise}
  706.  * @private
  707.  */
  708. shaka.media.MediaSourceEngine.prototype.enqueueOperation_ =
  709.     function(contentType, start) {
  710.   if (this.destroyed_) return Promise.reject();
  712.   var operation = {
  713.     start: start,
  714.     p: new shaka.util.PublicPromise()
  715.   };
  716.   this.queues_[contentType].push(operation);
  718.   if (this.queues_[contentType].length == 1) {
  719.     try {
  720.       operation.start();
  721.     } catch (exception) {
  722.       if (exception.name == 'QuotaExceededError') {
  723.         operation.p.reject(new shaka.util.Error(
  724.             shaka.util.Error.Severity.CRITICAL,
  725.             shaka.util.Error.Category.MEDIA,
  726.             shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  727.             contentType));
  728.       } else {
  729.         operation.p.reject(new shaka.util.Error(
  730.             shaka.util.Error.Severity.CRITICAL,
  731.             shaka.util.Error.Category.MEDIA,
  732.             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  733.             exception));
  734.       }
  735.       this.popFromQueue_(contentType);
  736.     }
  737.   }
  738.   return operation.p;
  739. };
  742. /**
  743.  * Enqueue an operation which must block all other operations on all
  744.  * SourceBuffers.
  745.  *
  746.  * @param {function()} run
  747.  * @return {!Promise}
  748.  * @private
  749.  */
  750. shaka.media.MediaSourceEngine.prototype.enqueueBlockingOperation_ =
  751.     function(run) {
  752.   if (this.destroyed_) return Promise.reject();
  754.   var allWaiters = [];
  756.   // Enqueue a 'wait' operation onto each queue.
  757.   // This operation signals its readiness when it starts.
  758.   // When all wait operations are ready, the real operation takes place.
  759.   for (var contentType in this.sourceBuffers_) {
  760.     var ready = new shaka.util.PublicPromise();
  761.     var operation = {
  762.       start: function(ready) { ready.resolve(); }.bind(null, ready),
  763.       p: ready
  764.     };
  766.     this.queues_[contentType].push(operation);
  767.     allWaiters.push(ready);
  769.     if (this.queues_[contentType].length == 1) {
  770.       operation.start();
  771.     }
  772.   }
  774.   // Return a Promise to the real operation, which waits to begin until there
  775.   // are no other in-progress operations on any SourceBuffers.
  776.   return Promise.all(allWaiters).then(function() {
  777.     if (!COMPILED) {
  778.       // If we did it correctly, nothing is updating.
  779.       for (var contentType in this.sourceBuffers_) {
  780.         goog.asserts.assert(
  781.             this.sourceBuffers_[contentType].updating == false,
  782.             'SourceBuffers should not be updating after a blocking op!');
  783.       }
  784.     }
  786.     var ret;
  787.     // Run the real operation, which is synchronous.
  788.     try {
  789.       run();
  790.     } catch (exception) {
  791.       ret = Promise.reject(new shaka.util.Error(
  792.           shaka.util.Error.Severity.CRITICAL,
  793.           shaka.util.Error.Category.MEDIA,
  794.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  795.           exception));
  796.     }
  798.     // Unblock the queues.
  799.     for (var contentType in this.sourceBuffers_) {
  800.       this.popFromQueue_(contentType);
  801.     }
  803.     return ret;
  804.   }.bind(this), function() {
  805.     // One of the waiters failed, which means we've been destroyed.
  806.     goog.asserts.assert(this.destroyed_, 'Should be destroyed by now');
  807.     // We haven't popped from the queue.  Canceled waiters have been removed by
  808.     // destroy.  What's left now should just be resolved waiters.  In uncompiled
  809.     // mode, we will maintain good hygiene and make sure the assert at the end
  810.     // of destroy passes.  In compiled mode, the queues are wiped in destroy.
  811.     if (!COMPILED) {
  812.       for (var contentType in this.sourceBuffers_) {
  813.         if (this.queues_[contentType].length) {
  814.           goog.asserts.assert(
  815.               this.queues_[contentType].length == 1,
  816.               'Should be at most one item in queue!');
  817.           goog.asserts.assert(
  818.               allWaiters.indexOf(this.queues_[contentType][0].p) != -1,
  819.               'The item in queue should be one of our waiters!');
  820.           this.queues_[contentType].shift();
  821.         }
  822.       }
  823.     }
  824.     return Promise.reject();
  825.   }.bind(this));
  826. };
  829. /**
  830.  * Pop from the front of the queue and start a new operation.
  831.  * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  832.  * @private
  833.  */
  834. shaka.media.MediaSourceEngine.prototype.popFromQueue_ = function(contentType) {
  835.   // Remove the in-progress operation, which is now complete.
  836.   this.queues_[contentType].shift();
  837.   // Retrieve the next operation, if any, from the queue and start it.
  838.   var next = this.queues_[contentType][0];
  839.   if (next) {
  840.     try {
  841.       next.start();
  842.     } catch (exception) {
  843.       next.p.reject(new shaka.util.Error(
  844.           shaka.util.Error.Severity.CRITICAL,
  845.           shaka.util.Error.Category.MEDIA,
  846.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  847.           exception));
  848.       this.popFromQueue_(contentType);
  849.     }
  850.   }
  851. };