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