Source: lib/media/streaming_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.StreamingEngine');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.MediaSourceEngine');
  23. goog.require('shaka.media.Playhead');
  24. goog.require('shaka.net.Backoff');
  25. goog.require('shaka.net.NetworkingEngine');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.FakeEvent');
  28. goog.require('shaka.util.Functional');
  29. goog.require('shaka.util.IDestroyable');
  30. goog.require('shaka.util.ManifestParserUtils');
  31. goog.require('shaka.util.MapUtils');
  32. goog.require('shaka.util.MimeUtils');
  33. goog.require('shaka.util.Mp4Parser');
  34. goog.require('shaka.util.PublicPromise');
  35. goog.require('shaka.util.StreamUtils');
  39. /**
  40.  * Creates a StreamingEngine.
  41.  *
  42.  * The StreamingEngine is responsible for setting up the Manifest's Streams
  43.  * (i.e., for calling each Stream's createSegmentIndex() function), for
  44.  * downloading segments, for co-ordinating audio, video, and text buffering,
  45.  * and for handling Period transitions. The StreamingEngine provides an
  46.  * interface to switch between Streams, but it does not choose which Streams to
  47.  * switch to.
  48.  *
  49.  * The StreamingEngine notifies its owner when it needs to buffer a new Period,
  50.  * so its owner can choose which Streams within that Period to initially
  51.  * buffer. Moreover, the StreamingEngine also notifies its owner when any
  52.  * Stream within the current Period may be switched to, so its owner can switch
  53.  * bitrates, resolutions, or languages.
  54.  *
  55.  * The StreamingEngine does not need to be notified about changes to the
  56.  * Manifest's SegmentIndexes; however, it does need to be notified when new
  57.  * Periods are added to the Manifest, so it can set up that Period's Streams.
  58.  *
  59.  * To start the StreamingEngine the owner must first call configure() followed
  60.  * by init(). The StreamingEngine will then call onChooseStreams(p) when it
  61.  * needs to buffer Period p; it will then switch to the Streams returned from
  62.  * that function. The StreamingEngine will call onCanSwitch() when any
  63.  * Stream within the current Period may be switched to.
  64.  *
  65.  * The owner must call seeked() each time the playhead moves to a new location
  66.  * within the presentation timeline; however, the owner may forego calling
  67.  * seeked() when the playhead moves outside the presentation timeline.
  68.  *
  69.  * @param {shakaExtern.Manifest} manifest
  70.  * @param {shaka.media.StreamingEngine.PlayerInterface} playerInterface
  71.  *
  72.  * @constructor
  73.  * @struct
  74.  * @implements {shaka.util.IDestroyable}
  75.  */
  76. shaka.media.StreamingEngine = function(manifest, playerInterface) {
  77.   /** @private {?shaka.media.StreamingEngine.PlayerInterface} */
  78.   this.playerInterface_ = playerInterface;
  80.   /** @private {?shakaExtern.Manifest} */
  81.   this.manifest_ = manifest;
  83.   /** @private {?shakaExtern.StreamingConfiguration} */
  84.   this.config_ = null;
  86.   /** @private {number} */
  87.   this.bufferingGoalScale_ = 1;
  89.   /** @private {Promise} */
  90.   this.setupPeriodPromise_ = Promise.resolve();
  92.   /**
  93.    * Maps a Period's index to an object that indicates that either
  94.    *   1. the Period has not been set up (undefined)
  95.    *   2. the Period is being set up ([a PublicPromise, false]),
  96.    *   3. the Period is set up (i.e., all Streams within the Period are set up)
  97.    *      and can be switched to ([a PublicPromise, true]).
  98.    *
  99.    * @private {Array.<?{promise: shaka.util.PublicPromise, resolved: boolean}>}
  100.    */
  101.   this.canSwitchPeriod_ = [];
  103.   /**
  104.    * Maps a Stream's ID to an object that indicates that either
  105.    *   1. the Stream has not been set up (undefined)
  106.    *   2. the Stream is being set up ([a Promise instance, false]),
  107.    *   3. the Stream is set up and can be switched to
  108.    *      ([a Promise instance, true]).
  109.    *
  110.    * @private {Object.<number,
  111.    *                   ?{promise: shaka.util.PublicPromise, resolved: boolean}>}
  112.    */
  113.   this.canSwitchStream_ = {};
  115.   /**
  116.    * Maps a content type, e.g., 'audio', 'video', or 'text', to a MediaState.
  117.    *
  118.    * @private {Object.<shaka.util.ManifestParserUtils.ContentType,
  119.                        !shaka.media.StreamingEngine.MediaState_>}
  120.    */
  121.   this.mediaStates_ = {};
  123.   /**
  124.    * Set to true once one segment of each content type has been buffered.
  125.    *
  126.    * @private {boolean}
  127.    */
  128.   this.startupComplete_ = false;
  130.   /**
  131.    * Used for delay and backoff of failure callbacks, so that apps do not retry
  132.    * instantly.
  133.    *
  134.    * @private {shaka.net.Backoff}
  135.    */
  136.   this.failureCallbackBackoff_ = null;
  138.   /**
  139.    * Set to true on fatal error.  Interrupts fetchAndAppend_().
  140.    *
  141.    * @private {boolean}
  142.    */
  143.   this.fatalError_ = false;
  145.   /** @private {boolean} */
  146.   this.destroyed_ = false;
  147. };
  150. /**
  151.  * @typedef {{
  152.  *   variant: (?shakaExtern.Variant|undefined),
  153.  *   text: ?shakaExtern.Stream
  154.  * }}
  155.  *
  156.  * @property {(?shakaExtern.Variant|undefined)} variant
  157.  *   The chosen variant.  May be omitted for text re-init.
  158.  * @property {?shakaExtern.Stream} text
  159.  *   The chosen text stream.
  160.  */
  161. shaka.media.StreamingEngine.ChosenStreams;
  164. /**
  165.  * @typedef {{
  166.  *   playhead: !shaka.media.Playhead,
  167.  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  168.  *   netEngine: shaka.net.NetworkingEngine,
  169.  *   onChooseStreams: function(!shakaExtern.Period):
  170.  *                        shaka.media.StreamingEngine.ChosenStreams,
  171.  *   onCanSwitch: function(),
  172.  *   onError: function(!shaka.util.Error),
  173.  *   onEvent: function(!Event),
  174.  *   onManifestUpdate: function(),
  175.  *   onSegmentAppended: function(),
  176.  *   onInitialStreamsSetup: (function()|undefined),
  177.  *   onStartupComplete: (function()|undefined)}
  178.  * }}
  179.  *
  180.  * @property {!shaka.media.Playhead} playhead
  181.  *   The Playhead. The caller retains ownership.
  182.  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  183.  *   The MediaSourceEngine. The caller retains ownership.
  184.  * @property {shaka.net.NetworkingEngine} netEngine
  185.  *   The NetworkingEngine instance to use. The caller retains ownership.
  186.  * @property {function(!shakaExtern.Period):
  187.  *                shaka.media.StreamingEngine.ChosenStreams} onChooseStreams
  188.  *   Called by StreamingEngine when the given Period needs to be buffered.
  189.  *   StreamingEngine will switch to the variant and text stream returned from
  190.  *   this function.
  191.  *   The owner cannot call switch() directly until the StreamingEngine calls
  192.  *   onCanSwitch().
  193.  * @property {function()} onCanSwitch
  194.  *   Called by StreamingEngine when the Period is set up and switching is
  195.  *   permitted.
  196.  * @property {function(!shaka.util.Error)} onError
  197.  *   Called when an error occurs. If the error is recoverable (see
  198.  *   @link{shaka.util.Error}) then the caller may invoke either
  199.  *   StreamingEngine.switch*() or StreamingEngine.seeked() to attempt recovery.
  200.  * @property {function(!Event)} onEvent
  201.  *   Called when an event occurs that should be sent to the app.
  202.  * @property {function()} onManifestUpdate
  203.  *   Called when an embedded 'emsg' box should trigger a manifest update.
  204.  * @property {function()} onSegmentAppended
  205.  *   Called after a segment is successfully appended to a MediaSource.
  206.  * @property {(function()|undefined)} onInitialStreamsSetup
  207.  *   Optional callback which is called when the initial set of Streams have been
  208.  *   setup. Intended to be used by tests.
  209.  * @property {(function()|undefined)} onStartupComplete
  210.  *   Optional callback which is called when startup has completed. Intended to
  211.  *   be used by tests.
  212.  */
  213. shaka.media.StreamingEngine.PlayerInterface;
  216. /**
  217.  * @typedef {{
  218.  *   type: shaka.util.ManifestParserUtils.ContentType,
  219.  *   stream: shakaExtern.Stream,
  220.  *   lastStream: ?shakaExtern.Stream,
  221.  *   lastSegmentReference: shaka.media.SegmentReference,
  222.  *   restoreStreamAfterTrickPlay: ?shakaExtern.Stream,
  223.  *   needInitSegment: boolean,
  224.  *   needPeriodIndex: number,
  225.  *   endOfStream: boolean,
  226.  *   performingUpdate: boolean,
  227.  *   updateTimer: ?number,
  228.  *   waitingToClearBuffer: boolean,
  229.  *   waitingToFlushBuffer: boolean,
  230.  *   clearingBuffer: boolean,
  231.  *   recovering: boolean,
  232.  *   hasError: boolean,
  233.  *   resumeAt: number
  234.  * }}
  235.  *
  236.  * @description
  237.  * Contains the state of a logical stream, i.e., a sequence of segmented data
  238.  * for a particular content type. At any given time there is a Stream object
  239.  * associated with the state of the logical stream.
  240.  *
  241.  * @property {shaka.util.ManifestParserUtils.ContentType} type
  242.  *   The stream's content type, e.g., 'audio', 'video', or 'text'.
  243.  * @property {shakaExtern.Stream} stream
  244.  *   The current Stream.
  245.  * @property {?shakaExtern.Stream} lastStream
  246.  *   The Stream of the last segment that was appended.
  247.  * @property {shaka.media.SegmentReference} lastSegmentReference
  248.  *   The SegmentReference of the last segment that was appended.
  249.  * @property {?shakaExtern.Stream} restoreStreamAfterTrickPlay
  250.  *   The Stream to restore after trick play mode is turned off.
  251.  * @property {boolean} needInitSegment
  252.  *   True indicates that |stream|'s init segment must be inserted before the
  253.  *   next media segment is appended.
  254.  * @property {boolean} endOfStream
  255.  *   True indicates that the end of the buffer has hit the end of the
  256.  *   presentation.
  257.  * @property {number} needPeriodIndex
  258.  *   The index of the Period which needs to be buffered.
  259.  * @property {boolean} performingUpdate
  260.  *   True indicates that an update is in progress.
  261.  * @property {?number} updateTimer
  262.  *   A non-null value indicates that an update is scheduled.
  263.  * @property {boolean} waitingToClearBuffer
  264.  *   True indicates that the buffer must be cleared after the current update
  265.  *   finishes.
  266.  * @property {boolean} waitingToFlushBuffer
  267.  *   True indicates that the buffer must be flushed after it is cleared.
  268.  * @property {boolean} clearingBuffer
  269.  *   True indicates that the buffer is being cleared.
  270.  * @property {boolean} recovering
  271.  *   True indicates that the last segment was not appended because it could not
  272.  *   fit in the buffer.
  273.  * @property {boolean} hasError
  274.  *   True indicates that the stream has encountered an error and has stopped
  275.  *   updates.
  276.  * @property {number} resumeAt
  277.  *   An override for the time to start performing updates at.  If the playhead
  278.  *   is behind this time, update_() will still start fetching segments from
  279.  *   this time.  If the playhead is ahead of the time, this field is ignored.
  280.  */
  281. shaka.media.StreamingEngine.MediaState_;
  284. /**
  285.  * The minimum number seconds that will remain buffered after evicting media.
  286.  *
  287.  * @const {number}
  288.  */
  289. shaka.media.StreamingEngine.prototype.MIN_BUFFER_LENGTH = 2;
  292. /** @override */
  293. shaka.media.StreamingEngine.prototype.destroy = function() {
  294.   for (var type in this.mediaStates_) {
  295.     this.cancelUpdate_(this.mediaStates_[type]);
  296.   }
  298.   this.playerInterface_ = null;
  299.   this.manifest_ = null;
  300.   this.setupPeriodPromise_ = null;
  301.   this.canSwitchPeriod_ = null;
  302.   this.canSwitchStream_ = null;
  303.   this.mediaStates_ = null;
  304.   this.config_ = null;
  306.   this.destroyed_ = true;
  308.   return Promise.resolve();
  309. };
  312. /**
  313.  * Called by the Player to provide an updated configuration any time it changes.
  314.  * Will be called at least once before init().
  315.  *
  316.  * @param {shakaExtern.StreamingConfiguration} config
  317.  */
  318. shaka.media.StreamingEngine.prototype.configure = function(config) {
  319.   this.config_ = config;
  321.   // Create separate parameters for backoff during streaming failure.
  323.   /** @type {shakaExtern.RetryParameters} */
  324.   var failureRetryParams = {
  325.     // The term "attempts" includes the initial attempt, plus all retries.
  326.     // In order to see a delay, there would have to be at least 2 attempts.
  327.     maxAttempts: Math.max(config.retryParameters.maxAttempts, 2),
  328.     baseDelay: config.retryParameters.baseDelay,
  329.     backoffFactor: config.retryParameters.backoffFactor,
  330.     fuzzFactor: config.retryParameters.fuzzFactor,
  331.     timeout: 0  // irrelevant
  332.   };
  334.   // We don't want to ever run out of attempts.  The application should be
  335.   // allowed to retry streaming infinitely if it wishes.
  336.   var autoReset = true;
  337.   this.failureCallbackBackoff_ =
  338.       new shaka.net.Backoff(failureRetryParams, autoReset);
  339. };
  342. /**
  343.  * Initializes the StreamingEngine.
  344.  *
  345.  * After this function is called the StreamingEngine will call
  346.  * onChooseStreams(p) when it needs to buffer Period p and onCanSwitch() when
  347.  * any Stream within that Period may be switched to.
  348.  *
  349.  * After the StreamingEngine calls onChooseStreams(p) for the first time, it
  350.  * will begin setting up the Streams returned from that function and
  351.  * subsequently switch to them. However, the StreamingEngine will not begin
  352.  * setting up any other Streams until at least one segment from each of the
  353.  * initial set of Streams has been buffered (this reduces startup latency).
  354.  * After the StreamingEngine completes this startup phase it will begin setting
  355.  * up each Period's Streams (while buffering in parrallel).
  356.  *
  357.  * When the StreamingEngine needs to buffer the next Period it will have
  358.  * already set up that Period's Streams. So, when the StreamingEngine calls
  359.  * onChooseStreams(p) after the first time, the StreamingEngine will
  360.  * immediately switch to the Streams returned from that function.
  361.  *
  362.  * @return {!Promise}
  363.  */
  364. shaka.media.StreamingEngine.prototype.init = function() {
  365.   goog.asserts.assert(this.config_,
  366.       'StreamingEngine configure() must be called before init()!');
  368.   // Determine which Period we must buffer.
  369.   var playheadTime = this.playerInterface_.playhead.getTime();
  370.   var needPeriodIndex = this.findPeriodContainingTime_(playheadTime);
  372.   // Get the initial set of Streams.
  373.   var initialStreams = this.playerInterface_.onChooseStreams(
  374.       this.manifest_.periods[needPeriodIndex]);
  375.   if (!initialStreams.variant && !initialStreams.text) {
  376.     shaka.log.error('init: no Streams chosen');
  377.     return Promise.reject(new shaka.util.Error(
  378.         shaka.util.Error.Severity.CRITICAL,
  379.         shaka.util.Error.Category.STREAMING,
  380.         shaka.util.Error.Code.INVALID_STREAMS_CHOSEN));
  381.   }
  383.   // Setup the initial set of Streams and then begin each update cycle. After
  384.   // startup completes onUpdate_() will set up the remaining Periods.
  385.   return this.initStreams_(initialStreams).then(function() {
  386.     shaka.log.debug('init: completed initial Stream setup');
  388.     // Subtlety: onInitialStreamsSetup() may call switch() or seeked(), so we
  389.     // must schedule an update beforehand so |updateTimer| is set.
  390.     if (this.playerInterface_ && this.playerInterface_.onInitialStreamsSetup) {
  391.       shaka.log.v1('init: calling onInitialStreamsSetup()...');
  392.       this.playerInterface_.onInitialStreamsSetup();
  393.     }
  394.   }.bind(this));
  395. };
  398. /**
  399.  * Gets the current Period the stream is in.  This Period may not be initialized
  400.  * yet if canSwitch(period) has not been called yet.
  401.  * @return {shakaExtern.Period}
  402.  */
  403. shaka.media.StreamingEngine.prototype.getCurrentPeriod = function() {
  404.   var playheadTime = this.playerInterface_.playhead.getTime();
  405.   var needPeriodIndex = this.findPeriodContainingTime_(playheadTime);
  406.   return this.manifest_.periods[needPeriodIndex];
  407. };
  410. /**
  411.  * Gets the Period in which we are currently buffering.  This may be different
  412.  * from the Period which contains the Playhead.
  413.  * @return {?shakaExtern.Period}
  414.  */
  415. shaka.media.StreamingEngine.prototype.getActivePeriod = function() {
  416.   goog.asserts.assert(this.mediaStates_, 'Must be initialized');
  417.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  418.   var anyMediaState = this.mediaStates_[ContentType.VIDEO] ||
  419.                       this.mediaStates_[ContentType.AUDIO];
  420.   return anyMediaState ?
  421.          this.manifest_.periods[anyMediaState.needPeriodIndex] : null;
  422. };
  425. /**
  426.  * Gets a map of all the active streams.
  427.  * @return {!Object.<shaka.util.ManifestParserUtils.ContentType,
  428.  *                   shakaExtern.Stream>}
  429.  */
  430. shaka.media.StreamingEngine.prototype.getActiveStreams = function() {
  431.   goog.asserts.assert(this.mediaStates_, 'Must be initialized');
  432.   var MapUtils = shaka.util.MapUtils;
  433.   return MapUtils.map(
  434.       this.mediaStates_, function(state) {
  435.         // Don't tell the caller about trick play streams.  If we're in trick
  436.         // play, return the stream we will go back to after we exit trick play.
  437.         return state.restoreStreamAfterTrickPlay || state.stream;
  438.       });
  439. };
  442. /**
  443.  * Notifies StreamingEngine that a new text stream was added to the manifest.
  444.  * This initializes the given stream.  This returns a Promise that resolves when
  445.  * the stream has been set up.
  446.  *
  447.  * @param {shakaExtern.Stream} stream
  448.  * @return {!Promise}
  449.  */
  450. shaka.media.StreamingEngine.prototype.notifyNewTextStream = function(stream) {
  451.   return this.initStreams_({ text: stream });
  452. };
  455. /**
  456.  * Set trick play on or off.
  457.  * If trick play is on, related trick play streams will be used when possible.
  458.  * @param {boolean} on
  459.  */
  460. shaka.media.StreamingEngine.prototype.setTrickPlay = function(on) {
  461.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  463.   var mediaState = this.mediaStates_[ContentType.VIDEO];
  464.   if (!mediaState) return;
  466.   var stream = mediaState.stream;
  467.   if (!stream) return;
  469.   shaka.log.debug('setTrickPlay', on);
  470.   if (on) {
  471.     var trickModeVideo = stream.trickModeVideo;
  472.     if (!trickModeVideo) return;  // Can't engage trick play.
  474.     var normalVideo = mediaState.restoreStreamAfterTrickPlay;
  475.     if (normalVideo) return;  // Already in trick play.
  477.     shaka.log.debug('Engaging trick mode stream', trickModeVideo);
  478.     this.switchInternal_(trickModeVideo, false);
  479.     mediaState.restoreStreamAfterTrickPlay = stream;
  480.   } else {
  481.     var normalVideo = mediaState.restoreStreamAfterTrickPlay;
  482.     if (!normalVideo) return;
  484.     shaka.log.debug('Restoring non-trick-mode stream', normalVideo);
  485.     mediaState.restoreStreamAfterTrickPlay = null;
  486.     this.switchInternal_(normalVideo, true);
  487.   }
  488. };
  491. /**
  492.  * @param {shakaExtern.Variant} variant
  493.  * @param {boolean} clearBuffer
  494.  */
  495. shaka.media.StreamingEngine.prototype.switchVariant =
  496.     function(variant, clearBuffer) {
  497.   if (variant.video) {
  498.     this.switchInternal_(variant.video, clearBuffer);
  499.   }
  501.   if (variant.audio) {
  502.     this.switchInternal_(variant.audio, clearBuffer);
  503.   }
  504. };
  507. /**
  508.  * @param {shakaExtern.Stream} textStream
  509.  */
  510. shaka.media.StreamingEngine.prototype.switchTextStream = function(textStream) {
  511.   goog.asserts.assert(textStream && textStream.type == 'text',
  512.                       'Wrong stream type passed to switchTextStream!');
  513.   this.switchInternal_(textStream, /* clearBuffer */ true);
  514. };
  517. /**
  518.  * Switches to the given Stream. |stream| may be from any Variant or any
  519.  * Period.
  520.  *
  521.  * @param {shakaExtern.Stream} stream
  522.  * @param {boolean} clearBuffer
  523.  * @private
  524.  */
  525. shaka.media.StreamingEngine.prototype.switchInternal_ = function(
  526.     stream, clearBuffer) {
  527.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  528.   var mediaState = this.mediaStates_[/** @type {!ContentType} */(stream.type)];
  530.   if (!mediaState && stream.type == ContentType.TEXT &&
  531.       this.config_.ignoreTextStreamFailures) {
  532.     this.notifyNewTextStream(stream);
  533.     return;
  534.   }
  535.   goog.asserts.assert(mediaState, 'switch: expected mediaState to exist');
  536.   if (!mediaState) return;
  538.   // If we are selecting a stream from a different Period, then we need to
  539.   // handle a Period transition.  Simply ignore the given stream, assuming that
  540.   // Player will select the same track in onChooseStreams.
  541.   var periodIndex = this.findPeriodContainingStream_(stream);
  542.   if (clearBuffer && periodIndex != mediaState.needPeriodIndex) {
  543.     shaka.log.debug('switch: switching to stream in another Period; clearing ' +
  544.                     'buffer and changing Periods');
  545.     // handlePeriodTransition_ will be called on the next update because the
  546.     // current Period won't match the playhead Period.
  547.     this.clearAllBuffers_();
  548.     return;
  549.   }
  551.   if (mediaState.restoreStreamAfterTrickPlay) {
  552.     shaka.log.debug('switch during trick play mode', stream);
  554.     // Already in trick play mode, so stick with trick mode tracks if possible.
  555.     if (stream.trickModeVideo) {
  556.       // Use the trick mode stream, but revert to the new selection later.
  557.       mediaState.restoreStreamAfterTrickPlay = stream;
  558.       stream = stream.trickModeVideo;
  559.       shaka.log.debug('switch found trick play stream', stream);
  560.     } else {
  561.       // No special trick mode video for this stream!
  562.       mediaState.restoreStreamAfterTrickPlay = null;
  563.       shaka.log.debug('switch found no special trick play stream');
  564.     }
  565.   }
  567.   // Ensure the Period is ready.
  568.   var canSwitchRecord = this.canSwitchPeriod_[periodIndex];
  569.   goog.asserts.assert(
  570.       canSwitchRecord && canSwitchRecord.resolved,
  571.       'switch: expected Period ' + periodIndex + ' to be ready');
  572.   if (!canSwitchRecord || !canSwitchRecord.resolved) return;
  574.   // Sanity check. If the Period is ready then the Stream should be ready too.
  575.   canSwitchRecord = this.canSwitchStream_[stream.id];
  576.   goog.asserts.assert(canSwitchRecord && canSwitchRecord.resolved,
  577.                       'switch: expected Stream ' + stream.id + ' to be ready');
  578.   if (!canSwitchRecord || !canSwitchRecord.resolved) return;
  580.   if (mediaState.stream == stream) {
  581.     var streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  582.     shaka.log.debug('switch: Stream ' + streamTag + ' already active');
  583.     return;
  584.   }
  586.   if (stream.type == ContentType.TEXT) {
  587.     // Mime types are allowed to change for text streams.
  588.     // Reinitialize the text parser, but only if we are going to fetch the init
  589.     // segment again.
  590.     var fullMimeType = shaka.util.MimeUtils.getFullType(
  591.         stream.mimeType, stream.codecs);
  592.     this.playerInterface_.mediaSourceEngine.reinitText(fullMimeType);
  593.   }
  595.   mediaState.stream = stream;
  596.   mediaState.needInitSegment = true;
  598.   var streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  599.   shaka.log.debug('switch: switching to Stream ' + streamTag);
  601.   if (clearBuffer) {
  602.     if (mediaState.clearingBuffer) {
  603.       // We are already going to clear the buffer, but make sure it is also
  604.       // flushed.
  605.       mediaState.waitingToFlushBuffer = true;
  606.     } else if (mediaState.performingUpdate) {
  607.       // We are performing an update, so we have to wait until it's finished.
  608.       // onUpdate_() will call clearBuffer_() when the update has
  609.       // finished.
  610.       mediaState.waitingToClearBuffer = true;
  611.       mediaState.waitingToFlushBuffer = true;
  612.     } else {
  613.       // Cancel the update timer, if any.
  614.       this.cancelUpdate_(mediaState);
  615.       // Clear right away.
  616.       this.clearBuffer_(mediaState, /* flush */ true);
  617.     }
  618.   }
  619. };
  622. /**
  623.  * Notifies the StreamingEngine that the playhead has moved to a valid time
  624.  * within the presentation timeline.
  625.  */
  626. shaka.media.StreamingEngine.prototype.seeked = function() {
  627.   goog.asserts.assert(this.mediaStates_, 'Must not be destroyed');
  629.   var playheadTime = this.playerInterface_.playhead.getTime();
  630.   var isAllBuffered = Object.keys(this.mediaStates_).every(function(type) {
  631.     return this.playerInterface_.mediaSourceEngine.isBuffered(
  632.         type, playheadTime);
  633.   }.bind(this));
  635.   // Only treat as a buffered seek if every media state has a buffer.  For
  636.   // example, if we have buffered text but not video, we should still clear
  637.   // every buffer so all media states need the same Period.
  638.   if (isAllBuffered) {
  639.     shaka.log.debug(
  640.         '(all): seeked: buffered seek: playheadTime=' + playheadTime);
  641.     return;
  642.   }
  644.   // This was an unbuffered seek (for at least one stream), clear all buffers.
  645.   // Don't clear only some of the buffers because we can become stalled since
  646.   // the media states are waiting for different Periods.
  647.   shaka.log.debug('(all): seeked: unbuffered seek: clearing all buffers');
  648.   this.clearAllBuffers_();
  649. };
  652. /**
  653.  * Clears the buffer for every stream.  Unlike clearBuffer_, this will handle
  654.  * cases where a MediaState is performing an update.  After this runs, every
  655.  * MediaState will have a pending update.
  656.  * @private
  657.  */
  658. shaka.media.StreamingEngine.prototype.clearAllBuffers_ = function() {
  659.   for (var type in this.mediaStates_) {
  660.     var mediaState = this.mediaStates_[type];
  661.     var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  663.     if (mediaState.clearingBuffer) {
  664.       // We're already clearing the buffer, so we don't need to clear the
  665.       // buffer again.
  666.       shaka.log.debug(logPrefix, 'clear: already clearing the buffer');
  667.       continue;
  668.     }
  670.     if (mediaState.waitingToClearBuffer) {
  671.       // May not be performing an update, but an update will still happen.
  672.       // See: https://github.com/google/shaka-player/issues/334
  673.       shaka.log.debug(logPrefix, 'clear: already waiting');
  674.       continue;
  675.     }
  677.     if (mediaState.performingUpdate) {
  678.       // We are performing an update, so we have to wait until it's finished.
  679.       // onUpdate_() will call clearBuffer_() when the update has
  680.       // finished.
  681.       shaka.log.debug(logPrefix, 'clear: currently updating');
  682.       mediaState.waitingToClearBuffer = true;
  683.       continue;
  684.     }
  686.     if (this.playerInterface_.mediaSourceEngine.bufferStart(type) == null) {
  687.       // Nothing buffered.
  688.       shaka.log.debug(logPrefix, 'clear: nothing buffered');
  689.       if (mediaState.updateTimer == null) {
  690.         // Note: an update cycle stops when we buffer to the end of the
  691.         // presentation or Period, or when we raise an error.
  692.         this.scheduleUpdate_(mediaState, 0);
  693.       }
  694.       continue;
  695.     }
  697.     // An update may be scheduled, but we can just cancel it and clear the
  698.     // buffer right away. Note: clearBuffer_() will schedule the next update.
  699.     shaka.log.debug(logPrefix, 'clear: handling right now');
  700.     this.cancelUpdate_(mediaState);
  701.     this.clearBuffer_(mediaState, /* flush */ false);
  702.   }
  703. };
  706. /**
  707.  * Initializes the given streams and media states if required.  This will
  708.  * schedule updates for the given types.
  709.  *
  710.  * @param {shaka.media.StreamingEngine.ChosenStreams} chosenStreams
  711.  * @param {number=} opt_resumeAt
  712.  * @return {!Promise}
  713.  * @private
  714.  */
  715. shaka.media.StreamingEngine.prototype.initStreams_ = function(
  716.     chosenStreams, opt_resumeAt) {
  717.   goog.asserts.assert(this.config_,
  718.       'StreamingEngine configure() must be called before init()!');
  720.   // Determine which Period we must buffer.
  721.   var playheadTime = this.playerInterface_.playhead.getTime();
  722.   var needPeriodIndex = this.findPeriodContainingTime_(playheadTime);
  724.   // Init/re-init MediaSourceEngine. Note that a re-init is only valid for text.
  725.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  727.   /** @type {!Object.<!ContentType, shakaExtern.Stream>} */
  728.   var streamsByType = {};
  729.   /** @type {!Array.<shakaExtern.Stream>} */
  730.   var streams = [];
  732.   if (chosenStreams.variant && chosenStreams.variant.audio) {
  733.     streamsByType[ContentType.AUDIO] = chosenStreams.variant.audio;
  734.     streams.push(chosenStreams.variant.audio);
  735.   }
  736.   if (chosenStreams.variant && chosenStreams.variant.video) {
  737.     streamsByType[ContentType.VIDEO] = chosenStreams.variant.video;
  738.     streams.push(chosenStreams.variant.video);
  739.   }
  740.   if (chosenStreams.text) {
  741.     streamsByType[ContentType.TEXT] = chosenStreams.text;
  742.     streams.push(chosenStreams.text);
  743.   }
  745.   // Init MediaSourceEngine.
  746.   this.playerInterface_.mediaSourceEngine.init(streamsByType);
  748.   this.setDuration_();
  750.   // Setup the initial set of Streams and then begin each update cycle. After
  751.   // startup completes onUpdate_() will set up the remaining Periods.
  752.   return this.setupStreams_(streams).then(function() {
  753.     if (this.destroyed_) return;
  755.     for (var type in streamsByType) {
  756.       var stream = streamsByType[type];
  757.       if (!this.mediaStates_[type]) {
  758.         this.mediaStates_[type] = {
  759.           stream: stream,
  760.           type: type,
  761.           lastStream: null,
  762.           lastSegmentReference: null,
  763.           restoreStreamAfterTrickPlay: null,
  764.           needInitSegment: true,
  765.           needPeriodIndex: needPeriodIndex,
  766.           endOfStream: false,
  767.           performingUpdate: false,
  768.           updateTimer: null,
  769.           waitingToClearBuffer: false,
  770.           waitingToFlushBuffer: false,
  771.           clearingBuffer: false,
  772.           recovering: false,
  773.           hasError: false,
  774.           resumeAt: opt_resumeAt || 0
  775.         };
  776.         this.scheduleUpdate_(this.mediaStates_[type], 0);
  777.       }
  778.     }
  779.   }.bind(this));
  780. };
  783. /**
  784.  * Sets up the given Period if necessary. Calls onError() if an error
  785.  * occurs.
  786.  *
  787.  * @param {number} periodIndex The Period's index.
  788.  * @return {!Promise} A Promise which is resolved when the given Period is
  789.  *   setup.
  790.  * @private
  791.  */
  792. shaka.media.StreamingEngine.prototype.setupPeriod_ = function(periodIndex) {
  793.   var Functional = shaka.util.Functional;
  794.   var canSwitchRecord = this.canSwitchPeriod_[periodIndex];
  795.   if (canSwitchRecord) {
  796.     shaka.log.debug(
  797.         '(all) Period ' + periodIndex + ' is being or has been set up');
  798.     goog.asserts.assert(canSwitchRecord.promise, 'promise must not be null');
  799.     return canSwitchRecord.promise;
  800.   }
  802.   shaka.log.debug('(all) setting up Period ' + periodIndex);
  803.   canSwitchRecord = {
  804.     promise: new shaka.util.PublicPromise(),
  805.     resolved: false
  806.   };
  807.   this.canSwitchPeriod_[periodIndex] = canSwitchRecord;
  809.   var streams = this.manifest_.periods[periodIndex].variants
  810.       .map(function(variant) {
  811.         var result = [];
  812.         if (variant.audio)
  813.           result.push(variant.audio);
  814.         if (variant.video)
  815.           result.push(variant.video);
  816.         if (variant.video && variant.video.trickModeVideo)
  817.           result.push(variant.video.trickModeVideo);
  818.         return result;
  819.       })
  820.       .reduce(Functional.collapseArrays, [])
  821.       .filter(Functional.isNotDuplicate);
  823.   // Add text streams
  824.   streams.push.apply(streams, this.manifest_.periods[periodIndex].textStreams);
  826.   // Serialize Period set up.
  827.   this.setupPeriodPromise_ = this.setupPeriodPromise_.then(function() {
  828.     if (this.destroyed_) return;
  829.     return this.setupStreams_(streams);
  830.   }.bind(this)).then(function() {
  831.     if (this.destroyed_) return;
  832.     this.canSwitchPeriod_[periodIndex].promise.resolve();
  833.     this.canSwitchPeriod_[periodIndex].resolved = true;
  834.     shaka.log.v1('(all) setup Period ' + periodIndex);
  835.   }.bind(this)).catch(function(error) {
  836.     if (this.destroyed_) return;
  837.     this.canSwitchPeriod_[periodIndex].promise.reject();
  838.     delete this.canSwitchPeriod_[periodIndex];
  839.     shaka.log.warning('(all) failed to setup Period ' + periodIndex);
  840.     this.playerInterface_.onError(error);
  841.     // Don't stop other Periods from being set up.
  842.   }.bind(this));
  844.   return canSwitchRecord.promise;
  845. };
  848. /**
  849.  * Sets up the given Streams if necessary. Does NOT call onError() if an
  850.  * error occurs.
  851.  *
  852.  * @param {!Array.<!shakaExtern.Stream>} streams
  853.  * @return {!Promise}
  854.  * @private
  855.  */
  856. shaka.media.StreamingEngine.prototype.setupStreams_ = function(streams) {
  857.   // Make sure that all the streams have unique ids.
  858.   // (Duplicate ids will cause the player to hang).
  859.   var uniqueStreamIds = streams.map(function(s) { return s.id; })
  860.                                .filter(shaka.util.Functional.isNotDuplicate);
  862.   goog.asserts.assert(uniqueStreamIds.length == streams.length,
  863.                       'streams should have unique ids');
  864.   // Parallelize Stream set up.
  865.   var async = [];
  867.   for (var i = 0; i < streams.length; ++i) {
  868.     var stream = streams[i];
  869.     var canSwitchRecord = this.canSwitchStream_[stream.id];
  871.     if (canSwitchRecord) {
  872.       shaka.log.debug(
  873.           '(all) Stream ' + stream.id + ' is being or has been set up');
  874.       async.push(canSwitchRecord.promise);
  875.     } else {
  876.       shaka.log.v1('(all) setting up Stream ' + stream.id);
  877.       this.canSwitchStream_[stream.id] = {
  878.         promise: new shaka.util.PublicPromise(),
  879.         resolved: false
  880.       };
  881.       async.push(stream.createSegmentIndex());
  882.     }
  883.   }
  885.   return Promise.all(async).then(function() {
  886.     if (this.destroyed_) return;
  888.     for (var i = 0; i < streams.length; ++i) {
  889.       var stream = streams[i];
  890.       var canSwitchRecord = this.canSwitchStream_[stream.id];
  891.       if (!canSwitchRecord.resolved) {
  892.         canSwitchRecord.promise.resolve();
  893.         canSwitchRecord.resolved = true;
  894.         shaka.log.v1('(all) setup Stream ' + stream.id);
  895.       }
  896.     }
  897.   }.bind(this)).catch(function(error) {
  898.     if (this.destroyed_) return;
  899.     this.canSwitchStream_[stream.id].promise.reject();
  900.     delete this.canSwitchStream_[stream.id];
  901.     return Promise.reject(error);
  902.   }.bind(this));
  903. };
  906. /**
  907.  * Sets the MediaSource's duration.
  908.  * @private
  909.  */
  910. shaka.media.StreamingEngine.prototype.setDuration_ = function() {
  911.   var duration = this.manifest_.presentationTimeline.getDuration();
  912.   if (duration < Infinity) {
  913.     this.playerInterface_.mediaSourceEngine.setDuration(duration);
  914.   } else {
  915.     // Not all platforms support infinite durations, so set a finite duration
  916.     // so we can append segments and so the user agent can seek.
  917.     this.playerInterface_.mediaSourceEngine.setDuration(Math.pow(2, 32));
  918.   }
  919. };
  922. /**
  923.  * Called when |mediaState|'s update timer has expired.
  924.  *
  925.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  926.  * @private
  927.  */
  928. shaka.media.StreamingEngine.prototype.onUpdate_ = function(mediaState) {
  929.   var MapUtils = shaka.util.MapUtils;
  930.   if (this.destroyed_) return;
  932.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  934.   // Sanity check.
  935.   goog.asserts.assert(
  936.       !mediaState.performingUpdate && (mediaState.updateTimer != null),
  937.       logPrefix + ' unexpected call to onUpdate_()');
  938.   if (mediaState.performingUpdate || (mediaState.updateTimer == null)) return;
  940.   goog.asserts.assert(
  941.       !mediaState.clearingBuffer,
  942.       logPrefix + ' onUpdate_() should not be called when clearing the buffer');
  943.   if (mediaState.clearingBuffer) return;
  945.   mediaState.updateTimer = null;
  947.   // Handle pending buffer clears.
  948.   if (mediaState.waitingToClearBuffer) {
  949.     // Note: clearBuffer_() will schedule the next update.
  950.     shaka.log.debug(logPrefix, 'skipping update and clearing the buffer');
  951.     this.clearBuffer_(mediaState, mediaState.waitingToFlushBuffer);
  952.     return;
  953.   }
  955.   // Update the MediaState.
  956.   try {
  957.     var delay = this.update_(mediaState);
  958.     if (delay != null) {
  959.       this.scheduleUpdate_(mediaState, delay);
  960.       mediaState.hasError = false;
  961.     }
  962.   } catch (error) {
  963.     this.handleStreamingError_(error);
  964.     return;
  965.   }
  967.   goog.asserts.assert(this.mediaStates_, 'must not be destroyed');
  969.   var mediaStates = MapUtils.values(this.mediaStates_);
  971.   // Check if we've buffered to the end of the Period.
  972.   this.handlePeriodTransition_(mediaState);
  974.   // Check if we've buffered to the end of the presentation.
  975.   if (mediaStates.every(function(ms) { return ms.endOfStream; })) {
  976.     shaka.log.v1(logPrefix, 'calling endOfStream()...');
  977.     this.playerInterface_.mediaSourceEngine.endOfStream().then(function() {
  978.       // If the media segments don't reach the end, then we need to update the
  979.       // timeline duration to match the final media duration to avoid buffering
  980.       // forever at the end.
  981.       var duration = this.playerInterface_.mediaSourceEngine.getDuration();
  982.       this.manifest_.presentationTimeline.setDuration(duration);
  983.     }.bind(this));
  984.   }
  985. };
  988. /**
  989.  * Updates the given MediaState.
  990.  *
  991.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  992.  * @return {?number} The number of seconds to wait until updating again or
  993.  *   null if another update does not need to be scheduled.
  994.  * @throws {!shaka.util.Error} if an error occurs.
  995.  * @private
  996.  */
  997. shaka.media.StreamingEngine.prototype.update_ = function(mediaState) {
  998.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1000.   // Compute how far we've buffered ahead of the playhead.
  1001.   var playheadTime = this.playerInterface_.playhead.getTime();
  1003.   // Get the next timestamp we need.
  1004.   var timeNeeded = this.getTimeNeeded_(mediaState, playheadTime);
  1005.   shaka.log.v2(logPrefix, 'timeNeeded=' + timeNeeded);
  1007.   var currentPeriodIndex = this.findPeriodContainingStream_(mediaState.stream);
  1008.   var needPeriodIndex = this.findPeriodContainingTime_(timeNeeded);
  1010.   // Get the amount of content we have buffered, accounting for drift.  This
  1011.   // is only used to determine if we have meet the buffering goal.  This should
  1012.   // be the same way that PlayheadObserver uses.
  1013.   var bufferedAhead = this.playerInterface_.mediaSourceEngine.bufferedAheadOf(
  1014.       mediaState.type, playheadTime);
  1016.   shaka.log.v2(logPrefix,
  1017.                'update_:',
  1018.                'playheadTime=' + playheadTime,
  1019.                'bufferedAhead=' + bufferedAhead);
  1021.   var bufferingGoal = this.getBufferingGoal_();
  1023.   // Check if we've buffered to the end of the presentation.
  1024.   if (timeNeeded >= this.manifest_.presentationTimeline.getDuration()) {
  1025.     // We shouldn't rebuffer if the playhead is close to the end of the
  1026.     // presentation.
  1027.     shaka.log.debug(logPrefix, 'buffered to end of presentation');
  1028.     mediaState.endOfStream = true;
  1029.     return null;
  1030.   }
  1031.   mediaState.endOfStream = false;
  1033.   // Check if we've buffered to the end of the Period. This should be done
  1034.   // before checking segment availability because the new Period may become
  1035.   // available once it's switched to. Note that we don't use the non-existence
  1036.   // of SegmentReferences as an indicator to determine Period boundaries
  1037.   // because SegmentIndexes can provide SegmentReferences outside its Period.
  1038.   mediaState.needPeriodIndex = needPeriodIndex;
  1039.   if (needPeriodIndex != currentPeriodIndex) {
  1040.     shaka.log.debug(logPrefix,
  1041.                     'need Period ' + needPeriodIndex,
  1042.                     'playheadTime=' + playheadTime,
  1043.                     'timeNeeded=' + timeNeeded,
  1044.                     'currentPeriodIndex=' + currentPeriodIndex);
  1045.     return null;
  1046.   }
  1048.   // If we've buffered to the buffering goal then schedule an update.
  1049.   if (bufferedAhead >= bufferingGoal) {
  1050.     shaka.log.v2(logPrefix, 'buffering goal met');
  1052.     // Do not try to predict the next update.  Just poll twice every second.
  1053.     // The playback rate can change at any time, so any prediction we make now
  1054.     // could be terribly invalid soon.
  1055.     return 0.5;
  1056.   }
  1058.   var bufferEnd =
  1059.       this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
  1060.   var reference = this.getSegmentReferenceNeeded_(
  1061.       mediaState, playheadTime, bufferEnd, currentPeriodIndex);
  1062.   if (!reference) {
  1063.     // The segment could not be found, does not exist, or is not available.  In
  1064.     // any case just try again... if the manifest is incomplete or is not being
  1065.     // updated then we'll idle forever; otherwise, we'll end up getting a
  1066.     // SegmentReference eventually.
  1067.     return 1;
  1068.   }
  1070.   mediaState.resumeAt = 0;
  1071.   this.fetchAndAppend_(mediaState, playheadTime, currentPeriodIndex, reference);
  1072.   return null;
  1073. };
  1076. /**
  1077.  * Computes buffering goal.
  1078.  *
  1079.  * @return {number}
  1080.  * @private
  1081.  */
  1082. shaka.media.StreamingEngine.prototype.getBufferingGoal_ = function() {
  1083.   goog.asserts.assert(this.manifest_, 'manifest_ should not be null');
  1084.   goog.asserts.assert(this.config_, 'config_ should not be null');
  1086.   var rebufferingGoal = shaka.util.StreamUtils.getRebufferingGoal(
  1087.       this.manifest_, this.config_, this.bufferingGoalScale_);
  1089.   return Math.max(
  1090.       rebufferingGoal,
  1091.       this.bufferingGoalScale_ * this.config_.bufferingGoal);
  1092. };
  1095. /**
  1096.  * Gets the next timestamp needed. Returns the playhead's position if the
  1097.  * buffer is empty; otherwise, returns the time at which the last segment
  1098.  * appended ends.
  1099.  *
  1100.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1101.  * @param {number} playheadTime
  1102.  * @return {number} The next timestamp needed.
  1103.  * @throws {!shaka.util.Error} if the buffer is inconsistent with our
  1104.  *   expectations.
  1105.  * @private
  1106.  */
  1107. shaka.media.StreamingEngine.prototype.getTimeNeeded_ = function(
  1108.     mediaState, playheadTime) {
  1109.   // Get the next timestamp we need. We must use |lastSegmentReference|
  1110.   // to determine this and not the actual buffer for two reasons:
  1111.   //   1. actual segments end slightly before their advertised end times, so
  1112.   //      the next timestamp we need is actually larger than |bufferEnd|; and
  1113.   //   2. there may be drift (the timestamps in the segments are ahead/behind
  1114.   //      of the timestamps in the manifest), but we need drift free times when
  1115.   //      comparing times against presentation and Period boundaries.
  1116.   if (!mediaState.lastStream || !mediaState.lastSegmentReference) {
  1117.     return Math.max(playheadTime, mediaState.resumeAt);
  1118.   }
  1120.   var lastPeriodIndex =
  1121.       this.findPeriodContainingStream_(mediaState.lastStream);
  1122.   var lastPeriod = this.manifest_.periods[lastPeriodIndex];
  1123.   return lastPeriod.startTime + mediaState.lastSegmentReference.endTime;
  1124. };
  1127. /**
  1128.  * Gets the SegmentReference of the next segment needed.
  1129.  *
  1130.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1131.  * @param {number} playheadTime
  1132.  * @param {?number} bufferEnd
  1133.  * @param {number} currentPeriodIndex
  1134.  * @return {shaka.media.SegmentReference} The SegmentReference of the
  1135.  *   next segment needed, or null if a segment could not be found, does not
  1136.  *   exist, or is not available.
  1137.  * @private
  1138.  */
  1139. shaka.media.StreamingEngine.prototype.getSegmentReferenceNeeded_ = function(
  1140.     mediaState, playheadTime, bufferEnd, currentPeriodIndex) {
  1141.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1143.   if (mediaState.lastSegmentReference &&
  1144.       mediaState.stream == mediaState.lastStream) {
  1145.     // Something is buffered from the same Stream.
  1146.     var position = mediaState.lastSegmentReference.position + 1;
  1147.     shaka.log.v2(logPrefix, 'next position known:', 'position=' + position);
  1149.     return this.getSegmentReferenceIfAvailable_(
  1150.         mediaState, currentPeriodIndex, position);
  1151.   }
  1153.   var position;
  1155.   if (mediaState.lastSegmentReference) {
  1156.     // Something is buffered from another Stream.
  1157.     goog.asserts.assert(mediaState.lastStream, 'lastStream should not be null');
  1158.     shaka.log.v1(logPrefix, 'next position unknown: another Stream buffered');
  1159.     var lastPeriodIndex =
  1160.         this.findPeriodContainingStream_(mediaState.lastStream);
  1161.     var lastPeriod = this.manifest_.periods[lastPeriodIndex];
  1162.     position = this.lookupSegmentPosition_(
  1163.         mediaState,
  1164.         lastPeriod.startTime + mediaState.lastSegmentReference.endTime,
  1165.         currentPeriodIndex);
  1166.   } else {
  1167.     // Either nothing is buffered, or we have cleared part of the buffer.  If
  1168.     // we still have some buffered, use that time to find the segment, otherwise
  1169.     // start at the playhead time.
  1170.     goog.asserts.assert(!mediaState.lastStream, 'lastStream should be null');
  1171.     shaka.log.v1(logPrefix, 'next position unknown: nothing buffered');
  1172.     position = this.lookupSegmentPosition_(
  1173.         mediaState, bufferEnd || playheadTime, currentPeriodIndex);
  1174.   }
  1176.   if (position == null)
  1177.     return null;
  1179.   var reference = null;
  1180.   if (bufferEnd == null) {
  1181.     // If there's positive drift then we need to get the previous segment;
  1182.     // however, we don't actually know how much drift there is, so we must
  1183.     // unconditionally get the previous segment. If it turns out that there's
  1184.     // non-positive drift then we'll just end up buffering beind the playhead a
  1185.     // little more than we needed.
  1186.     var optimalPosition = Math.max(0, position - 1);
  1187.     reference = this.getSegmentReferenceIfAvailable_(
  1188.         mediaState, currentPeriodIndex, optimalPosition);
  1189.   }
  1190.   return reference ||
  1191.       this.getSegmentReferenceIfAvailable_(
  1192.           mediaState, currentPeriodIndex, position);
  1193. };
  1196. /**
  1197.  * Looks up the position of the segment containing the given timestamp.
  1198.  *
  1199.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1200.  * @param {number} presentationTime The timestamp needed, relative to the
  1201.  *   start of the presentation.
  1202.  * @param {number} currentPeriodIndex
  1203.  * @return {?number} A segment position, or null if a segment was not be found.
  1204.  * @private
  1205.  */
  1206. shaka.media.StreamingEngine.prototype.lookupSegmentPosition_ = function(
  1207.     mediaState, presentationTime, currentPeriodIndex) {
  1208.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1209.   var currentPeriod = this.manifest_.periods[currentPeriodIndex];
  1211.   shaka.log.debug(logPrefix,
  1212.                   'looking up segment:',
  1213.                   'presentationTime=' + presentationTime,
  1214.                   'currentPeriod.startTime=' + currentPeriod.startTime);
  1216.   var lookupTime = Math.max(0, presentationTime - currentPeriod.startTime);
  1217.   var position = mediaState.stream.findSegmentPosition(lookupTime);
  1219.   if (position == null) {
  1220.     shaka.log.warning(logPrefix,
  1221.                       'cannot find segment:',
  1222.                       'currentPeriod.startTime=' + currentPeriod.startTime,
  1223.                       'lookupTime=' + lookupTime);
  1224.   }
  1226.   return position;
  1227. };
  1230. /**
  1231.  * Gets the SegmentReference at the given position if it's available.
  1232.  *
  1233.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1234.  * @param {number} currentPeriodIndex
  1235.  * @param {number} position
  1236.  * @return {shaka.media.SegmentReference}
  1237.  *
  1238.  * @private
  1239.  */
  1240. shaka.media.StreamingEngine.prototype.getSegmentReferenceIfAvailable_ =
  1241.     function(mediaState, currentPeriodIndex, position) {
  1242.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1243.   var currentPeriod = this.manifest_.periods[currentPeriodIndex];
  1245.   var reference = mediaState.stream.getSegmentReference(position);
  1246.   if (!reference) {
  1247.     shaka.log.v1(logPrefix,
  1248.                  'segment does not exist:',
  1249.                  'currentPeriod.startTime=' + currentPeriod.startTime,
  1250.                  'position=' + position);
  1251.     return null;
  1252.   }
  1254.   var timeline = this.manifest_.presentationTimeline;
  1255.   var availabilityStart = timeline.getSegmentAvailabilityStart();
  1256.   var availabilityEnd = timeline.getSegmentAvailabilityEnd();
  1258.   if ((currentPeriod.startTime + reference.endTime < availabilityStart) ||
  1259.       (currentPeriod.startTime + reference.startTime > availabilityEnd)) {
  1260.     shaka.log.v2(logPrefix,
  1261.                  'segment is not available:',
  1262.                  'currentPeriod.startTime=' + currentPeriod.startTime,
  1263.                  'reference.startTime=' + reference.startTime,
  1264.                  'reference.endTime=' + reference.endTime,
  1265.                  'availabilityStart=' + availabilityStart,
  1266.                  'availabilityEnd=' + availabilityEnd);
  1267.     return null;
  1268.   }
  1270.   return reference;
  1271. };
  1274. /**
  1275.  * Fetches and appends the given segment; sets up the given MediaState's
  1276.  * associated SourceBuffer and evicts segments if either are required
  1277.  * beforehand. Schedules another update after completing successfully.
  1278.  *
  1279.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1280.  * @param {number} playheadTime
  1281.  * @param {number} currentPeriodIndex The index of the current Period.
  1282.  * @param {!shaka.media.SegmentReference} reference
  1283.  * @private
  1284.  */
  1285. shaka.media.StreamingEngine.prototype.fetchAndAppend_ = function(
  1286.     mediaState, playheadTime, currentPeriodIndex, reference) {
  1287.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1288.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1289.   var currentPeriod = this.manifest_.periods[currentPeriodIndex];
  1291.   shaka.log.v1(logPrefix,
  1292.                'fetchAndAppend_:',
  1293.                'playheadTime=' + playheadTime,
  1294.                'currentPeriod.startTime=' + currentPeriod.startTime,
  1295.                'reference.position=' + reference.position,
  1296.                'reference.startTime=' + reference.startTime,
  1297.                'reference.endTime=' + reference.endTime);
  1299.   // Subtlety: The playhead may move while asynchronous update operations are
  1300.   // in progress, so we should avoid calling playhead.getTime() in any
  1301.   // callbacks. Furthermore, switch() may be called at any time, so we should
  1302.   // also avoid using mediaState.stream or mediaState.needInitSegment in any
  1303.   // callbacks too.
  1304.   var stream = mediaState.stream;
  1306.   // Compute the append window end.
  1307.   var followingPeriod = this.manifest_.periods[currentPeriodIndex + 1];
  1308.   var appendWindowEnd = null;
  1309.   if (followingPeriod) {
  1310.     appendWindowEnd = followingPeriod.startTime;
  1311.   } else {
  1312.     appendWindowEnd = this.manifest_.presentationTimeline.getDuration();
  1313.   }
  1314.   goog.asserts.assert(
  1315.       (appendWindowEnd == null) || (reference.startTime <= appendWindowEnd),
  1316.       logPrefix + ' segment should start before append window end');
  1318.   var initSourceBuffer =
  1319.       this.initSourceBuffer_(mediaState, currentPeriodIndex, appendWindowEnd);
  1321.   mediaState.performingUpdate = true;
  1323.   // We may set |needInitSegment| to true in switch(), so set it to false here,
  1324.   // since we want it to remain true if switch() is called.
  1325.   mediaState.needInitSegment = false;
  1327.   shaka.log.v2(logPrefix, 'fetching segment');
  1328.   var fetchSegment = this.fetch_(reference);
  1330.   Promise.all([initSourceBuffer, fetchSegment]).then(function(results) {
  1331.     if (this.destroyed_ || this.fatalError_) return;
  1332.     return this.append_(mediaState,
  1333.                         playheadTime,
  1334.                         currentPeriod,
  1335.                         stream,
  1336.                         reference,
  1337.                         results[1]);
  1338.   }.bind(this)).then(function() {
  1339.     if (this.destroyed_ || this.fatalError_) return;
  1341.     mediaState.performingUpdate = false;
  1342.     mediaState.recovering = false;
  1344.     if (!mediaState.waitingToClearBuffer)
  1345.       this.playerInterface_.onSegmentAppended();
  1347.     // Update right away.
  1348.     this.scheduleUpdate_(mediaState, 0);
  1350.     // Subtlety: handleStartup_() calls onStartupComplete() which may call
  1351.     // switch() or seeked(), so we must schedule an update beforehand so
  1352.     // |updateTimer| is set.
  1353.     this.handleStartup_(mediaState, stream);
  1355.     shaka.log.v1(logPrefix, 'finished fetch and append');
  1356.   }.bind(this)).catch(function(error) {
  1357.     if (this.destroyed_ || this.fatalError_) return;
  1358.     goog.asserts.assert(error instanceof shaka.util.Error,
  1359.                         'Should only receive a Shaka error');
  1361.     mediaState.performingUpdate = false;
  1363.     if (mediaState.type == ContentType.TEXT &&
  1364.         this.config_.ignoreTextStreamFailures) {
  1365.       if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  1366.         shaka.log.warning(logPrefix,
  1367.             'Text stream failed to download. Proceeding without it.');
  1368.       } else {
  1369.         shaka.log.warning(logPrefix,
  1370.             'Text stream failed to parse. Proceeding without it.');
  1371.       }
  1373.       delete this.mediaStates_[ContentType.TEXT];
  1374.     } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
  1375.       this.handleQuotaExceeded_(mediaState, error);
  1376.     } else {
  1377.       shaka.log.error(logPrefix, 'failed fetch and append: code=' + error.code);
  1378.       mediaState.hasError = true;
  1380.       error.severity = shaka.util.Error.Severity.CRITICAL;
  1381.       this.handleStreamingError_(error);
  1382.     }
  1383.   }.bind(this));
  1384. };
  1387. /**
  1388.  * Clear per-stream error states and retry any failed streams.
  1389.  * @return {boolean} False if unable to retry.
  1390.  */
  1391. shaka.media.StreamingEngine.prototype.retry = function() {
  1392.   if (this.destroyed_) {
  1393.     shaka.log.error('Unable to retry after StreamingEngine is destroyed!');
  1394.     return false;
  1395.   }
  1397.   if (this.fatalError_) {
  1398.     shaka.log.error('Unable to retry after StreamingEngine encountered a ' +
  1399.                     'fatal error!');
  1400.     return false;
  1401.   }
  1403.   for (var type in this.mediaStates_) {
  1404.     var mediaState = this.mediaStates_[type];
  1405.     var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1406.     if (mediaState.hasError) {
  1407.       shaka.log.info(logPrefix, 'Retrying after failure...');
  1408.       mediaState.hasError = false;
  1409.       this.scheduleUpdate_(mediaState, 0.1);
  1410.     }
  1411.   }
  1413.   return true;
  1414. };
  1417. /**
  1418.  * Handles a QUOTA_EXCEEDED_ERROR.
  1419.  *
  1420.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1421.  * @param {!shaka.util.Error} error
  1422.  * @private
  1423.  */
  1424. shaka.media.StreamingEngine.prototype.handleQuotaExceeded_ = function(
  1425.     mediaState, error) {
  1426.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1428.   // The segment cannot fit into the SourceBuffer. Ideally, MediaSource would
  1429.   // have evicted old data to accommodate the segment; however, it may have
  1430.   // failed to do this if the segment is very large, or if it could not find
  1431.   // a suitable time range to remove.
  1432.   //
  1433.   // We can overcome the latter by trying to append the segment again;
  1434.   // however, to avoid continuous QuotaExceededErrors we must reduce the size
  1435.   // of the buffer going forward.
  1436.   //
  1437.   // If we've recently reduced the buffering goals, wait until the stream
  1438.   // which caused the first QuotaExceededError recovers. Doing this ensures
  1439.   // we don't reduce the buffering goals too quickly.
  1441.   goog.asserts.assert(this.mediaStates_, 'must not be destroyed');
  1442.   var mediaStates = shaka.util.MapUtils.values(this.mediaStates_);
  1443.   var waitingForAnotherStreamToRecover = mediaStates.some(function(ms) {
  1444.     return ms != mediaState && ms.recovering;
  1445.   });
  1447.   if (!waitingForAnotherStreamToRecover) {
  1448.     // Reduction schedule: 80%, 60%, 40%, 20%, 16%, 12%, 8%, 4%, fail.
  1449.     // Note: percentages are used for comparisons to avoid rounding errors.
  1450.     var percentBefore = Math.round(100 * this.bufferingGoalScale_);
  1451.     if (percentBefore > 20) {
  1452.       this.bufferingGoalScale_ -= 0.2;
  1453.     } else if (percentBefore > 4) {
  1454.       this.bufferingGoalScale_ -= 0.04;
  1455.     } else {
  1456.       shaka.log.error(
  1457.           logPrefix, 'MediaSource threw QuotaExceededError too many times');
  1458.       mediaState.hasError = true;
  1459.       this.fatalError_ = true;
  1460.       this.playerInterface_.onError(error);
  1461.       return;
  1462.     }
  1463.     var percentAfter = Math.round(100 * this.bufferingGoalScale_);
  1464.     shaka.log.warning(
  1465.         logPrefix,
  1466.         'MediaSource threw QuotaExceededError:',
  1467.         'reducing buffering goals by ' + (100 - percentAfter) + '%');
  1468.     mediaState.recovering = true;
  1469.   } else {
  1470.     shaka.log.debug(
  1471.         logPrefix,
  1472.         'MediaSource threw QuotaExceededError:',
  1473.         'waiting for another stream to recover...');
  1474.   }
  1476.   // QuotaExceededError gets thrown if evication didn't help to make room
  1477.   // for a segment. We want to wait for a while (4 seconds is just an
  1478.   // arbitrary number) before updating to give the playhead a chance to
  1479.   // advance, so we don't immidiately throw again.
  1480.   this.scheduleUpdate_(mediaState, 4);
  1481. };
  1484. /**
  1485.  * Sets the given MediaState's associated SourceBuffer's timestamp offset and
  1486.  * init segment if either are required. If an error occurs then neither the
  1487.  * timestamp offset or init segment are unset, since another call to switch()
  1488.  * will end up superseding them.
  1489.  *
  1490.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1491.  * @param {number} currentPeriodIndex
  1492.  * @param {?number} appendWindowEnd
  1493.  * @return {!Promise}
  1494.  * @private
  1495.  */
  1496. shaka.media.StreamingEngine.prototype.initSourceBuffer_ = function(
  1497.     mediaState, currentPeriodIndex, appendWindowEnd) {
  1498.   if (!mediaState.needInitSegment)
  1499.     return Promise.resolve();
  1501.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1502.   var currentPeriod = this.manifest_.periods[currentPeriodIndex];
  1504.   // If we need an init segment then the Stream switched, so we've either
  1505.   // changed bitrates, Periods, or both. If we've changed Periods then we must
  1506.   // set a new timestamp offset and append window end. Note that by setting
  1507.   // these values here, we avoid having to co-ordinate ongoing updates, which
  1508.   // we would have to do if we instead set them in switch().
  1509.   var timestampOffset =
  1510.       currentPeriod.startTime - mediaState.stream.presentationTimeOffset;
  1511.   shaka.log.v1(logPrefix, 'setting timestamp offset to ' + timestampOffset);
  1512.   shaka.log.v1(logPrefix, 'setting append window end to ' + appendWindowEnd);
  1513.   var setStreamProperties =
  1514.       this.playerInterface_.mediaSourceEngine.setStreamProperties(
  1515.           mediaState.type, timestampOffset, appendWindowEnd);
  1517.   if (!mediaState.stream.initSegmentReference) {
  1518.     // The Stream is self initializing.
  1519.     return setStreamProperties;
  1520.   }
  1522.   shaka.log.v1(logPrefix, 'fetching init segment');
  1523.   var fetchInit = this.fetch_(mediaState.stream.initSegmentReference);
  1524.   var appendInit = fetchInit.then(function(initSegment) {
  1525.     if (this.destroyed_) return;
  1526.     shaka.log.v1(logPrefix, 'appending init segment');
  1528.     return this.playerInterface_.mediaSourceEngine.appendBuffer(
  1529.         mediaState.type, initSegment, null /* startTime */, null /* endTime */);
  1530.   }.bind(this)).catch(function(error) {
  1531.     mediaState.needInitSegment = true;
  1532.     return Promise.reject(error);
  1533.   });
  1535.   return Promise.all([setStreamProperties, appendInit]);
  1536. };
  1539. /**
  1540.  * Appends the given segment and evicts content if required to append.
  1541.  *
  1542.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1543.  * @param {number} playheadTime
  1544.  * @param {shakaExtern.Period} period
  1545.  * @param {shakaExtern.Stream} stream
  1546.  * @param {!shaka.media.SegmentReference} reference
  1547.  * @param {!ArrayBuffer} segment
  1548.  * @return {!Promise}
  1549.  * @private
  1550.  */
  1551. shaka.media.StreamingEngine.prototype.append_ = function(
  1552.     mediaState, playheadTime, period, stream, reference, segment) {
  1553.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1555.   if (stream.containsEmsgBoxes) {
  1556.     new shaka.util.Mp4Parser()
  1557.         .fullBox('emsg', this.parseEMSG_.bind(this, period, reference))
  1558.         .parse(segment);
  1559.   }
  1561.   return this.evict_(mediaState, playheadTime).then(function() {
  1562.     if (this.destroyed_) return;
  1563.     shaka.log.v1(logPrefix, 'appending media segment');
  1565.     return this.playerInterface_.mediaSourceEngine.appendBuffer(
  1566.         mediaState.type, segment, reference.startTime + period.startTime,
  1567.         reference.endTime + period.startTime);
  1568.   }.bind(this)).then(function() {
  1569.     if (this.destroyed_) return;
  1570.     shaka.log.v2(logPrefix, 'appended media segment');
  1572.     // We must use |stream| because switch() may have been called.
  1573.     mediaState.lastStream = stream;
  1574.     mediaState.lastSegmentReference = reference;
  1576.     return Promise.resolve();
  1577.   }.bind(this));
  1578. };
  1581. /**
  1582.  * Parse the EMSG box from a MP4 container.
  1583.  *
  1584.  * @param {!shakaExtern.Period} period
  1585.  * @param {!shaka.media.SegmentReference} reference
  1586.  * @param {!shaka.util.Mp4Parser.ParsedBox} box
  1587.  * @private
  1588.  */
  1589. shaka.media.StreamingEngine.prototype.parseEMSG_ = function(
  1590.     period, reference, box) {
  1592.   var schemeId = box.reader.readTerminatedString();
  1593.   // read rest of the data and dispatch event to the application
  1594.   var value = box.reader.readTerminatedString();
  1595.   var timescale = box.reader.readUint32();
  1596.   var presentationTimeDelta = box.reader.readUint32();
  1597.   var eventDuration = box.reader.readUint32();
  1598.   var id = box.reader.readUint32();
  1599.   var messageData = box.reader.readBytes(
  1600.       box.reader.getLength() - box.reader.getPosition());
  1602.   var startTime = period.startTime + reference.startTime +
  1603.       (presentationTimeDelta / timescale);
  1605.   // See DASH sec. 5.10.4.1
  1606.   // A special scheme in DASH used to signal manifest updates.
  1607.   if (schemeId == 'urn:mpeg:dash:event:2012') {
  1608.     this.playerInterface_.onManifestUpdate();
  1609.   } else {
  1610.     /** @type {shakaExtern.EmsgInfo} */
  1611.     var emsg = {
  1612.       startTime: startTime,
  1613.       endTime: startTime + (eventDuration / timescale),
  1614.       schemeIdUri: schemeId,
  1615.       value: value,
  1616.       timescale: timescale,
  1617.       presentationTimeDelta: presentationTimeDelta,
  1618.       eventDuration: eventDuration,
  1619.       id: id,
  1620.       messageData: messageData
  1621.     };
  1623.     var event = new shaka.util.FakeEvent('emsg', {'detail': emsg});
  1624.     this.playerInterface_.onEvent(event);
  1625.   }
  1626. };
  1629. /**
  1630.  * Evicts media to meet the max buffer behind limit.
  1631.  *
  1632.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1633.  * @param {number} playheadTime
  1634.  * @return {!Promise}
  1635.  * @private
  1636.  */
  1637. shaka.media.StreamingEngine.prototype.evict_ = function(
  1638.     mediaState, playheadTime) {
  1639.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1640.   shaka.log.v2(logPrefix, 'checking buffer length');
  1642.   var startTime =
  1643.       this.playerInterface_.mediaSourceEngine.bufferStart(mediaState.type);
  1644.   if (startTime == null) {
  1645.     shaka.log.v2(logPrefix,
  1646.                  'buffer behind okay because nothing buffered:',
  1647.                  'playheadTime=' + playheadTime,
  1648.                  'bufferBehind=' + this.config_.bufferBehind);
  1649.     return Promise.resolve();
  1650.   }
  1651.   var bufferedBehind = playheadTime - startTime;
  1653.   var overflow = bufferedBehind - this.config_.bufferBehind;
  1654.   if (overflow <= 0) {
  1655.     shaka.log.v2(logPrefix,
  1656.                  'buffer behind okay:',
  1657.                  'playheadTime=' + playheadTime,
  1658.                  'bufferedBehind=' + bufferedBehind,
  1659.                  'bufferBehind=' + this.config_.bufferBehind,
  1660.                  'underflow=' + (-overflow));
  1661.     return Promise.resolve();
  1662.   }
  1664.   shaka.log.v1(logPrefix,
  1665.                'buffer behind too large:',
  1666.                'playheadTime=' + playheadTime,
  1667.                'bufferedBehind=' + bufferedBehind,
  1668.                'bufferBehind=' + this.config_.bufferBehind,
  1669.                'overflow=' + overflow);
  1671.   return this.playerInterface_.mediaSourceEngine.remove(
  1672.       mediaState.type, startTime, startTime + overflow).then(function() {
  1673.     if (this.destroyed_) return;
  1674.     shaka.log.v1(logPrefix, 'evicted ' + overflow + ' seconds');
  1675.   }.bind(this));
  1676. };
  1679. /**
  1680.  * Sets up all known Periods when startup completes; otherwise, does nothing.
  1681.  *
  1682.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState The last
  1683.  *   MediaState updated.
  1684.  * @param {shakaExtern.Stream} stream
  1685.  * @private
  1686.  */
  1687. shaka.media.StreamingEngine.prototype.handleStartup_ = function(
  1688.     mediaState, stream) {
  1689.   var Functional = shaka.util.Functional;
  1690.   var MapUtils = shaka.util.MapUtils;
  1691.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1692.   if (this.startupComplete_)
  1693.     return;
  1695.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1697.   goog.asserts.assert(this.mediaStates_, 'must not be destroyed');
  1698.   var mediaStates = MapUtils.values(this.mediaStates_);
  1699.   this.startupComplete_ = mediaStates.every(function(ms) {
  1700.     // Startup completes once we have buffered at least one segment from each
  1701.     // MediaState, not counting text.
  1702.     if (ms.type == ContentType.TEXT) return true;
  1703.     return !ms.waitingToClearBuffer &&
  1704.            !ms.clearingBuffer &&
  1705.            ms.lastSegmentReference;
  1706.   });
  1708.   if (!this.startupComplete_)
  1709.     return;
  1711.   shaka.log.debug(logPrefix, 'startup complete');
  1713.   // We must use |stream| because switch() may have been called.
  1714.   var currentPeriodIndex = this.findPeriodContainingStream_(stream);
  1716.   goog.asserts.assert(
  1717.       mediaStates.every(function(ms) {
  1718.         // It is possible for one stream (usually text) to buffer the whole
  1719.         // Period and need the next one.
  1720.         return ms.needPeriodIndex == currentPeriodIndex ||
  1721.             ms.needPeriodIndex == currentPeriodIndex + 1;
  1722.       }),
  1723.       logPrefix + ' expected all MediaStates to need same Period');
  1725.   // Setup the current Period if necessary, which is likely since the current
  1726.   // Period is probably the initial one.
  1727.   if (!this.canSwitchPeriod_[currentPeriodIndex]) {
  1728.     this.setupPeriod_(currentPeriodIndex).then(function() {
  1729.       shaka.log.v1(logPrefix, 'calling onCanSwitch()...');
  1730.       this.playerInterface_.onCanSwitch();
  1731.     }.bind(this)).catch(Functional.noop);
  1732.   }
  1734.   // Now setup all known Periods.
  1735.   for (var i = 0; i < this.manifest_.periods.length; ++i) {
  1736.     this.setupPeriod_(i).catch(Functional.noop);
  1737.   }
  1739.   if (this.playerInterface_.onStartupComplete) {
  1740.     shaka.log.v1(logPrefix, 'calling onStartupComplete()...');
  1741.     this.playerInterface_.onStartupComplete();
  1742.   }
  1743. };
  1746. /**
  1747.  * Calls onChooseStreams() when necessary.
  1748.  *
  1749.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState The last
  1750.  *   MediaState updated.
  1751.  * @private
  1752.  */
  1753. shaka.media.StreamingEngine.prototype.handlePeriodTransition_ = function(
  1754.     mediaState) {
  1755.   var Functional = shaka.util.Functional;
  1756.   var MapUtils = shaka.util.MapUtils;
  1757.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1758.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1760.   var currentPeriodIndex = this.findPeriodContainingStream_(mediaState.stream);
  1761.   if (mediaState.needPeriodIndex == currentPeriodIndex)
  1762.     return;
  1764.   var needPeriodIndex = mediaState.needPeriodIndex;
  1766.   goog.asserts.assert(this.mediaStates_, 'must not be destroyed');
  1767.   var mediaStates = MapUtils.values(this.mediaStates_);
  1769.   // For a Period transition to work, all media states must need the same
  1770.   // Period.  If a stream needs a different Period than the one it currently
  1771.   // has, it will try to transition or stop updates assuming that another stream
  1772.   // will handle it.  This only works when all streams either need the same
  1773.   // Period or are still performing updates.
  1774.   goog.asserts.assert(
  1775.       mediaStates.every(function(ms) {
  1776.         return ms.needPeriodIndex == needPeriodIndex || ms.hasError ||
  1777.             !shaka.media.StreamingEngine.isIdle_(ms);
  1778.       }),
  1779.       'All MediaStates should need the same Period or be performing updates.');
  1781.   // Only call onChooseStreams() when all MediaStates need the same Period.
  1782.   var needSamePeriod = mediaStates.every(function(ms) {
  1783.     return ms.needPeriodIndex == needPeriodIndex;
  1784.   });
  1785.   if (!needSamePeriod) {
  1786.     shaka.log.debug(
  1787.         logPrefix, 'not all MediaStates need Period ' + needPeriodIndex);
  1788.     return;
  1789.   }
  1791.   // Only call onChooseStreams() once per Period transition.
  1792.   var allAreIdle = mediaStates.every(shaka.media.StreamingEngine.isIdle_);
  1793.   if (!allAreIdle) {
  1794.     shaka.log.debug(
  1795.         logPrefix,
  1796.         'all MediaStates need Period ' + needPeriodIndex + ', ' +
  1797.         'but not all MediaStates are idle');
  1798.     return;
  1799.   }
  1801.   shaka.log.debug(logPrefix, 'all need Period ' + needPeriodIndex);
  1803.   // Ensure the Period which we need to buffer is setup and then call
  1804.   // onChooseStreams().
  1805.   this.setupPeriod_(needPeriodIndex).then(function() {
  1806.     if (this.destroyed_) return;
  1808.     // If we seek during a Period transition, we can start another transition.
  1809.     // So we need to verify that:
  1810.     // - We are still in need of the same Period.
  1811.     // - All streams are still idle.
  1812.     // - The current stream is not in the needed Period (another transition
  1813.     //   handled it).
  1814.     var allReady = mediaStates.every(function(ms) {
  1815.       var isIdle = shaka.media.StreamingEngine.isIdle_(ms);
  1816.       var currentPeriodIndex = this.findPeriodContainingStream_(ms.stream);
  1817.       return isIdle && ms.needPeriodIndex == needPeriodIndex &&
  1818.           currentPeriodIndex != needPeriodIndex;
  1819.     }.bind(this));
  1820.     if (!allReady) {
  1821.       // TODO: Write unit tests for this case.
  1822.       shaka.log.debug(logPrefix, 'ignoring transition to Period',
  1823.                       needPeriodIndex, 'since another is happening');
  1824.       return;
  1825.     }
  1827.     var needPeriod = this.manifest_.periods[needPeriodIndex];
  1829.     shaka.log.v1(logPrefix, 'calling onChooseStreams()...');
  1830.     var chosenStreams = this.playerInterface_.onChooseStreams(needPeriod);
  1831.     var streamsByType = {};
  1832.     if (chosenStreams.variant && chosenStreams.variant.video) {
  1833.       streamsByType[ContentType.VIDEO] = chosenStreams.variant.video;
  1834.     }
  1835.     if (chosenStreams.variant && chosenStreams.variant.audio) {
  1836.       streamsByType[ContentType.AUDIO] = chosenStreams.variant.audio;
  1837.     }
  1838.     if (chosenStreams.text) {
  1839.       streamsByType[ContentType.TEXT] = chosenStreams.text;
  1840.     }
  1842.     // Vet |streamsByType| before switching.
  1843.     for (var type in this.mediaStates_) {
  1844.       if (streamsByType[type] || type == ContentType.TEXT) continue;
  1846.       shaka.log.error(logPrefix,
  1847.                       'invalid Streams chosen: missing ' + type + ' Stream');
  1848.       this.playerInterface_.onError(new shaka.util.Error(
  1849.           shaka.util.Error.Severity.CRITICAL,
  1850.           shaka.util.Error.Category.STREAMING,
  1851.           shaka.util.Error.Code.INVALID_STREAMS_CHOSEN));
  1852.       return;
  1853.     }
  1855.     for (var type in streamsByType) {
  1856.       if (this.mediaStates_[/** @type {!ContentType} */(type)]) continue;
  1858.       if (type == ContentType.TEXT) {
  1859.         // initStreams_ will switch streams and schedule an update.
  1860.         this.initStreams_(
  1861.             {text: streamsByType[ContentType.TEXT]}, needPeriod.startTime);
  1862.         delete streamsByType[type];
  1863.         continue;
  1864.       }
  1866.       shaka.log.error(logPrefix,
  1867.                       'invalid Streams chosen: unusable ' + type + ' Stream');
  1868.       this.playerInterface_.onError(new shaka.util.Error(
  1869.           shaka.util.Error.Severity.CRITICAL,
  1870.           shaka.util.Error.Category.STREAMING,
  1871.           shaka.util.Error.Code.INVALID_STREAMS_CHOSEN));
  1872.       return;
  1873.     }
  1875.     for (var type in this.mediaStates_) {
  1876.       var stream = streamsByType[type];
  1877.       if (stream) {
  1878.         this.switchInternal_(stream, /* clearBuffer */ false);
  1879.         this.scheduleUpdate_(this.mediaStates_[type], 0);
  1880.       } else {
  1881.         goog.asserts.assert(type == ContentType.TEXT, 'Invalid streams chosen');
  1882.         delete this.mediaStates_[type];
  1883.       }
  1884.     }
  1886.     // We've already set up the Period so call onCanSwitch() right now.
  1887.     shaka.log.v1(logPrefix, 'calling onCanSwitch()...');
  1888.     this.playerInterface_.onCanSwitch();
  1889.   }.bind(this)).catch(Functional.noop);
  1890. };
  1893. /**
  1894.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1895.  * @return {boolean} True if the given MediaState is idle; otherwise, return
  1896.  *   false.
  1897.  * @private
  1898.  */
  1899. shaka.media.StreamingEngine.isIdle_ = function(mediaState) {
  1900.   return !mediaState.performingUpdate &&
  1901.          (mediaState.updateTimer == null) &&
  1902.          !mediaState.waitingToClearBuffer &&
  1903.          !mediaState.clearingBuffer;
  1904. };
  1907. /**
  1908.  * @param {number} time The time, in seconds, relative to the start of the
  1909.  *   presentation.
  1910.  * @return {number} The index of the Period which starts after |time|
  1911.  * @private
  1912.  */
  1913. shaka.media.StreamingEngine.prototype.findPeriodContainingTime_ = function(
  1914.     time) {
  1915.   goog.asserts.assert(this.manifest_, 'Must not be destroyed');
  1916.   return shaka.util.StreamUtils.findPeriodContainingTime(this.manifest_, time);
  1917. };
  1920. /**
  1921.  * @param {!shakaExtern.Stream} stream
  1922.  * @return {number} The index of the Period which contains |stream|, or -1 if
  1923.  *   no Period contains |stream|.
  1924.  * @private
  1925.  */
  1926. shaka.media.StreamingEngine.prototype.findPeriodContainingStream_ = function(
  1927.     stream) {
  1928.   goog.asserts.assert(this.manifest_, 'Must not be destroyed');
  1929.   return shaka.util.StreamUtils.findPeriodContainingStream(
  1930.       this.manifest_, stream);
  1931. };
  1934. /**
  1935.  * Fetches the given segment.
  1936.  *
  1937.  * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
  1938.  *   reference
  1939.  *
  1940.  * @return {!Promise.<!ArrayBuffer>}
  1941.  * @private
  1942.  */
  1943. shaka.media.StreamingEngine.prototype.fetch_ = function(reference) {
  1944.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1945.   var request = shaka.net.NetworkingEngine.makeRequest(
  1946.       reference.getUris(), this.config_.retryParameters);
  1948.   // Set Range header. Note that some web servers don't accept Range headers,
  1949.   // so don't set one if it's not strictly required.
  1950.   if ((reference.startByte != 0) || (reference.endByte != null)) {
  1951.     var range = 'bytes=' + reference.startByte + '-';
  1952.     if (reference.endByte != null) range += reference.endByte;
  1953.     request.headers['Range'] = range;
  1954.   }
  1956.   shaka.log.v2('fetching: reference=' + reference);
  1957.   var p = this.playerInterface_.netEngine.request(requestType, request);
  1958.   return p.then(function(response) {
  1959.     return response.data;
  1960.   });
  1961. };
  1964. /**
  1965.  * Clears the buffer and schedules another update.
  1966.  *
  1967.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1968.  * @param {boolean} flush
  1969.  * @private
  1970.  */
  1971. shaka.media.StreamingEngine.prototype.clearBuffer_ =
  1972.     function(mediaState, flush) {
  1973.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1975.   goog.asserts.assert(
  1976.       !mediaState.performingUpdate && (mediaState.updateTimer == null),
  1977.       logPrefix + ' unexpected call to clearBuffer_()');
  1979.   mediaState.waitingToClearBuffer = false;
  1980.   mediaState.waitingToFlushBuffer = false;
  1981.   mediaState.clearingBuffer = true;
  1983.   shaka.log.debug(logPrefix, 'clearing buffer');
  1984.   var p = this.playerInterface_.mediaSourceEngine.clear(mediaState.type);
  1985.   p.then(function() {
  1986.     if (!this.destroyed_ && flush) {
  1987.       return this.playerInterface_.mediaSourceEngine.flush(mediaState.type);
  1988.     }
  1989.   }.bind(this)).then(function() {
  1990.     if (this.destroyed_) return;
  1991.     shaka.log.debug(logPrefix, 'cleared buffer');
  1992.     mediaState.lastStream = null;
  1993.     mediaState.lastSegmentReference = null;
  1994.     mediaState.clearingBuffer = false;
  1995.     mediaState.endOfStream = false;
  1996.     this.scheduleUpdate_(mediaState, 0);
  1997.   }.bind(this));
  1998. };
  2001. /**
  2002.  * Schedules |mediaState|'s next update.
  2003.  *
  2004.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2005.  * @param {number} delay The delay in seconds.
  2006.  * @private
  2007.  */
  2008. shaka.media.StreamingEngine.prototype.scheduleUpdate_ = function(
  2009.     mediaState, delay) {
  2010.   var logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  2011.   shaka.log.v2(logPrefix, 'updating in ' + delay + ' seconds');
  2012.   goog.asserts.assert(mediaState.updateTimer == null,
  2013.                       logPrefix + ' did not expect update to be scheduled');
  2014.   mediaState.updateTimer = window.setTimeout(
  2015.       this.onUpdate_.bind(this, mediaState), delay * 1000);
  2016. };
  2019. /**
  2020.  * Cancels |mediaState|'s next update if one exists.
  2021.  *
  2022.  * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2023.  * @private
  2024.  */
  2025. shaka.media.StreamingEngine.prototype.cancelUpdate_ = function(mediaState) {
  2026.   if (mediaState.updateTimer != null) {
  2027.     window.clearTimeout(mediaState.updateTimer);
  2028.     mediaState.updateTimer = null;
  2029.   }
  2030. };
  2033. /**
  2034.  * Handle streaming errors by delaying, then notifying the application by error
  2035.  * callback and by streaming failure callback.
  2036.  *
  2037.  * @param {!shaka.util.Error} error
  2038.  * @private
  2039.  */
  2040. shaka.media.StreamingEngine.prototype.handleStreamingError_ = function(error) {
  2041.   // If we invoke the callback right away, the application could trigger a
  2042.   // rapid retry cycle that could be very unkind to the server.  Instead,
  2043.   // use the backoff system to delay and backoff the error handling.
  2044.   this.failureCallbackBackoff_.attempt().then(function() {
  2045.     // First fire an error event.
  2046.     this.playerInterface_.onError(error);
  2048.     // If the error was not handled by the application, call the failure
  2049.     // callback.
  2050.     if (!error.handled) {
  2051.       this.config_.failureCallback(error);
  2052.     }
  2053.   }.bind(this));
  2054. };
  2057. /**
  2058.  * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2059.  * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,
  2060.  *   "(audio:5)" or "(video:hd)".
  2061.  * @private
  2062.  */
  2063. shaka.media.StreamingEngine.logPrefix_ = function(mediaState) {
  2064.   return '(' + mediaState.type + ':' + mediaState.stream.id + ')';
  2065. };